#include<cstdio>
#include<vector>
#include<stack>
#include<algorithm>
using namespace std;
ifstream fin("biconex.in"); ofstream fout("biconex.out");

int n, m, index, lowlink[100001], tata[100001], entry_time[100001];
vector <int> G[100001];
vector <vector <int> > sol;
stack <int> bcStack;

void DFS(int nod){
	int i, adj;
	
	bcStack.push(nod);
	lowlink[nod] = entry_time[nod] = ++index;
	vector <int> newbc;
	
	for (i = 0; i < (int)G[nod].size(); i++){
		adj = G[nod][i];
		
		if (!entry_time[adj]) {
			tata[adj] = nod;
			DFS(adj);
			// la intoarcerea din recursie, lowlink[tata] = min lowlink[fii]
			lowlink[nod] = min (lowlink[nod], lowlink[adj]);
		}
		// am intalnit o muchie de intoarcere
		else if (tata[nod] != adj) 
			lowlink[nod] = min (lowlink[nod], lowlink[adj]);		
	}
	
	if (lowlink[nod] == entry_time[nod]){
		do	{
			adj = bcStack.top(), bcStack.pop();
			newbc.push_back(adj);
		}
		while (nod != adj);		
		if (newbc.size() > 1)sol.push_back(newbc);
		//daca este cazul, adauga comp biconexa formata din nodul de articulatie si tatal lui
		if (tata[nod]){
			newbc.clear();
			newbc.push_back(nod), newbc.push_back(tata[nod]);
			sol.push_back(newbc);
		}
	}
}

int main(){
	int i, j, x, y;
	fin >> n >> m;
	for (i = 0; i <= m; i++){
		fin >> x >> y;
		G[x].push_back(y);
		G[y].push_back(x);
	}
	
	for (i = 1; i <= n ;i++)
		if (!entry_time[i]) DFS(i);
	
	fout << sol.size() << "\n";
	for (i = 0; i < (int)sol.size(); i++){
		for (j = 0; j < (int)sol[i].size(); j++)
			fout << sol[i][j] << " ";
		fout << "\n";
	}
}