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

const int kNmax = 100005, ALB = 0, GRI = 1, NEGRU = 2;

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

 private:
	int n;
	int m;
	vector<int> adj[kNmax];
    vector<int> adjT[kNmax];
	void read_input() {
		ifstream fin("ctc.in");
		fin >> n >> m;
		for (int i = 1, x, y; i <= m; i++) {
			fin >> x >> y;
			adj[x].push_back(y);
			adjT[y].push_back(x);
		}
		fin.close();
	}
    void dfs(int nod, vector<int> &cul, stack<int> &s) {
        cul[nod] = GRI;
        for(unsigned i = 0; i < adj[nod].size(); ++i) {
            int fiu = adj[nod][i];
            if(cul[fiu] == ALB) {
                dfs(fiu, cul, s);
            }
        }
        cul[nod] = NEGRU;
        s.push(nod);
    }
    void dfsT(int nod, vector<int> &cul, vector<int> &comp) {
        cul[nod] = GRI;
        comp.push_back(nod);
        for(unsigned i = 0; i < adjT[nod].size(); ++i) {
            int fiu = adjT[nod][i];
            if(cul[fiu] == ALB) {
                dfsT(fiu, cul, comp);
            }
        }

        cul[nod] = NEGRU;
    }
	vector<vector<int> > get_result() {
	    vector<vector<int> > sol;
		vector<int> cul(n + 1, ALB);
		stack<int> s;
        for(int i = 1; i <= n; ++i) {
            if(cul[i] == ALB) {
                dfs(i, cul, s);
            }
        }
        for(int i = 1; i <= n; ++i) {
            cul[i] = ALB;
        }
        while(!s.empty()) {
            int nod = s.top();
            s.pop();

            if(cul[nod] == ALB) {
                vector<int> comp;
                dfsT(nod, cul, comp);
                sol.push_back(comp);
            }

        }
		return sol;
	}

	void print_output(vector<vector<int> > result) {
		ofstream fout("ctc.out");
		fout << result.size() << '\n';
		for(unsigned i = 0; i < result.size(); ++i) {
            for (unsigned j = 0; j < result[i].size(); j++) {
                fout << result[i][j] << (j == result[i].size() - 1 ? '\n' : ' ');
            }
		}

		fout.close();
	}
};

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

 private:
	int n;
	int m;
	int index;
	vector<int> adj[kNmax];
	vector<int> idx, low, tata;
	stack<pair<int, int> > s;
	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);
		}
		idx.resize(n + 1, 0);
		low.resize(n + 1, 0);
		tata.resize(n + 1, 0);
		fin.close();
	}
	void dfs(int nod, vector<vector<int> > &sol) {
        ++index;
        idx[nod] = low[nod] = index;

        for(unsigned i = 0; i < adj[nod].size(); ++i) {
            int fiu = adj[nod][i];
            if(tata[nod] == fiu) {
                continue;
            }
            if(idx[fiu] == 0) {
                s.push({nod, fiu});
                tata[fiu] = nod;
                dfs(fiu, sol);
                if(low[nod] > low[fiu]) {
                    low[nod] = low[fiu];
                }
                if(idx[nod] <= low[fiu]) {
                    vector<int> comp;
                    while(1) {
                        pair<int, int> muc = s.top();
                        s.pop();
                        comp.push_back(muc.second);
                        if(muc.first == nod && muc.second == fiu) {
                            break;
                        }
                    }
                    comp.push_back(nod);
                    sol.push_back(comp);
                    comp.clear();
                }
            } else { ///suntem pe muchie de intoarcere
                low[nod] = min(low[nod], idx[fiu]);
            }
        }

	}
	vector<vector<int> > get_result() {
	    vector<vector<int> > sol;
        dfs(1, sol);

		return sol;
	}

	void print_output(vector<vector<int> > result) {
		ofstream fout("biconex.out");
		fout << result.size() << '\n';
		for(unsigned i = 0; i < result.size(); ++i) {
            for (unsigned j = 0; j < result[i].size(); j++) {
                fout << result[i][j] << (j == result[i].size() - 1 ? '\n' : ' ');
            }
		}

		fout.close();
	}
};
int main() {
	Tarjan *tar = new Tarjan();
	tar->solve();
	delete tar;
	return 0;
}