#include <fstream>
#include <vector>
#include <stack>
#include <algorithm>

using namespace std;

const int kNmax = 100000;

int n;
int m;
vector<int> adj[kNmax + 1];
vector<int> idx, low;
stack<int> stk;
vector <vector <int> > result;

void read_input() {
	ifstream fin("biconex.in");
	fin >> n >> m;
	for (int i = 1, x, y; i <= m; i++) {
		fin >> x >> y;
		adj[x].push_back(y);
		adj[y].push_back(x);
	}
	fin.close();
}

int min(int a, int b) {
	return a < b ? a : b;
}

void make_bicon_comp(int node, int son) {
	vector<int> cur_comp;
	int cur;

	do {
		cur = stk.top();

		stk.pop();

		cur_comp.push_back(cur);

	} while (cur != son);

	cur_comp.push_back(node);
	result.push_back(cur_comp);
}

void cut_vertex(int node, int parent, int time) {
	idx[node] = low[node] = time;

	vector <int>::iterator it;
	for (it = adj[node].begin(); it != adj[node].end(); it++) {
		if (*it == parent) {
			continue;
		}

		if (idx[*it] == 0) {
			stk.push(*it);
			cut_vertex(*it, node, time + 1);

			low[node] = min(low[node], low[*it]);

			if (low[*it] >= idx[node]) {
				make_bicon_comp(node, *it);
			}
		} else {
			low[node] = min(low[node], idx[*it]);
		}
	}
}

void get_result() {
	/*
	TODO: Gasiti nodurile critice ale grafului neorientat stocat cu liste
	de adiacenta in adj.
	*/

	idx.resize(n + 1);
	low.resize(n + 1);
	idx.assign(n + 1, 0);

	cut_vertex(1, 0, 1);

}

void print_output() {
	ofstream fout("biconex.out");
	fout << result.size() << '\n';
	for (int i = 0; i < result.size(); i++) {
		//sort(result[i].begin(), result[i].end());
		for (int nod : result[i]) {
			fout << nod << ' ';
		}
		fout << '\n';
	}
	fout.close();
}


int main() {
	read_input();
	get_result();
	print_output();
}