#include <fstream>
using namespace std;
ifstream fin("ctc.in");
ofstream fout("ctc.out");
const int maxN = 100001;

struct graph {
    int node;
    graph *next;
} *G[maxN], *GT[maxN];

struct component_node {
    int node;
    component_node *next;
} *nodes_of_component[maxN];

int component_of[maxN];
int partial_component_of[maxN];

int N, M;

void dfs(int i, int ID) {
    partial_component_of[i] = ID;
    for(graph *p = G[i]; p != NULL; p = p ->next)
        if(!component_of[p->node] && partial_component_of[p->node] != ID)
            dfs(p->node, ID);
}

void inverse_dfs(int i, int ID) {
    if(partial_component_of[i] != ID)
        return;
    component_of[i] = ID;
    component_node *p = new component_node;
    p ->node = i;
    p ->next = nodes_of_component[ID];
    nodes_of_component[ID] = p;

    for(graph *p = GT[i]; p != NULL; p = p ->next)
        if(!component_of[p->node])
            inverse_dfs(p->node, ID);
}

void read_graphs() {
    for(; M; M--) {
        int a, b;
        fin >> a >> b;
        graph *p = new graph;
        p ->node = b;
        p ->next = G[a];
        G[a] = p;
        p = new graph;
        p ->node = a;
        p ->next = GT[b];
        GT[b] = p;
    }
}

int main()
{
    fin >> N >> M;
    read_graphs();

    int nr_of_components = 0;
    for(int i=1; i<=N; i++)
        if(!component_of[i]) {
            dfs(i, ++nr_of_components);
            inverse_dfs(i, nr_of_components);
        }

    fout << nr_of_components << '\n';
    for(int i=1; i<=nr_of_components; i++) {
        for(component_node *p = nodes_of_component[i]; p != NULL; p = p->next)
            fout << p->node << ' ';
        fout << '\n';
    }

	fin.close();
	fout.close();
	return 0;
}