#include <fstream>
#include <vector>
#include <algorithm>
#include <queue>
#include <iostream>
#include <stack>
using namespace std;

const int kNmax = 100005;

class Task {
public:
	void solve() {
		read_input();
		print_output(get_result());
	}

private:
	int n;
	int m;
	vector<int> adj[kNmax];

	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();
	}

	void dfs(int node, int &index, vector<int>& discover,
	         vector<int>& link, vector<vector<int> > &sol, stack<int> &stack) {
		stack.push(node);
		discover[node] = index;
		link[node] = index;
		++index;

		for (auto neigh : adj[node]) {
			if (discover[neigh] == -1) {
				dfs(neigh, index, discover, link, sol, stack);
				link[node] = min(link[node], link[neigh]);
				if (link[neigh] >= discover[node]) {
					vector <int> biconex;
					biconex.push_back(node);
					while (stack.top() != neigh) {
						biconex.push_back(stack.top());
						stack.pop();
					}
					// neigh in biconne
					biconex.push_back(stack.top());
					stack.pop();
					sol.push_back(biconex);
				}
			} else {
				link[node] = min(link[node], discover[neigh]);
			}
		}
	}

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

		vector<vector<int> > sol;
		vector<int> discover(n + 1, -1);
		vector<int> link(n + 1);
		stack<int> stack;
		int index = 0;
		for (int i = 1; i <= n; ++i)
			if (discover[i] == -1) // undiscovered
				dfs(i, index, discover, link, sol, stack);
		return sol;
	}

	void print_output(vector<vector<int>> result) {
		ofstream fout("biconex.out");
		fout << result.size() << endl;
		for (int i = 0; i < int(result.size()); ++i) {
			for (int j = 0; j < int(result[i].size()); ++j)
				fout << result[i][j] << ' ';
			fout << endl;
		}
		fout.close();
	}
};

int main() {
	Task *task = new Task();
	task->solve();
	delete task;
	return 0;
}