#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <fstream>
#include <iterator>
using namespace std;

const string file = "biconex";

const string infile = file + ".in";
const string outfile = file + ".out";

const int INF = 0x3f3f3f3f;
int N, M;
vector<vector<int> > G;
vector<int> level;
vector<int> minLevel;

int Sol;
vector<vector<int> > biconex;
stack<int> stiva;

void dfs(int x, int nivel)
{
	level[x] = nivel;
	minLevel[x] = nivel;

	for(vector<int>::iterator itr = G[x].begin();
		itr != G[x].end();
		itr++)
	{
		if(level[*itr] == 0)
		{
			stiva.push(*itr);
			dfs(*itr, nivel + 1);
			minLevel[x] = min(minLevel[x], minLevel[*itr]);

			if(level[x] == minLevel[*itr])
			{
				Sol++;
				vector<int> newBiconex;
				int n = -1;
				while( n != *itr)
				{
					n = stiva.top();
					stiva.pop();
					newBiconex.push_back(n);
				}
				newBiconex.push_back(x);
				biconex.push_back(newBiconex);
			}
		}
		else 
		{
			minLevel[x] = min(minLevel[x], level[*itr]);
		}
	}

}

int main()
{
	fstream fin(infile.c_str(), ios::in);
	fin >> N >> M;
	G.resize(N + 1);
	level.resize(N + 1);
	minLevel.resize(N + 1);
	for(int i = 0; i < M; i++)
	{
		int x, y;
		fin >> x >> y;
		G[x].push_back(y);
		G[y].push_back(x);
	}
	fin.close();


	for(int i = 1; i <= N; i++)
	{
		if(level[i] == 0)
			dfs(i, 1);
	}


	fstream fout(outfile.c_str(), ios::out);
	fout << Sol << "\n";
	for(vector<vector<int> > ::iterator itr = biconex.begin();
		itr != biconex.end();
		itr++)
	{
		copy(itr->rbegin(), itr->rend(), ostream_iterator<int>(fout, " "));
		fout << "\n";
	}
	fout.close();
}