#include <iostream>
#include <fstream>
#include <list>
#include <algorithm>
#include <stack>

using namespace std;

ifstream f ("ctc.in");
ofstream g ("ctc.out");

int a[20001][20001], s = 0, u, t = 0;
class Graph
{
    int N;
    list<int> *adj;
    void Order(int x, bool visited[], stack<int> &Stack);
    void DFS(int x, bool visited[]);
    
    public:
    Graph(int N);
    void addEdge(int x, int y);
    Graph tr();
    void CTC();
};

Graph::Graph(int N)
{
    this->N = N;
    adj = new list<int>[N];
}

void Graph::DFS(int x, bool visited[])
{   
    visited[x] = true;
    a[s][t]=x;
    t++;
    u = t;
    list<int>::iterator i;
    for(i = adj[x].begin(); i != adj[x].end(); i++)
        if(!visited[*i])
            DFS(*i, visited);
}

Graph Graph::tr()
{
    Graph gr(N);
    for(int a = 0; a < N; a++)
    {
        list<int>::iterator i;
        for(i = adj[a].begin(); i != adj[a].end(); ++i)
        {
            gr.adj[*i].push_back(a);
        }
    }
    return gr;
}

void Graph::addEdge(int x, int y)
{
    adj[x].push_back(y);
}

void Graph::Order(int x, bool visited[], stack<int> &Stack)
{
    visited[x] = true;
    list<int>::iterator i;
    
    for(i = adj[x].begin(); i != adj[x].end(); i++)
        if(!visited[*i])
            Order(*i, visited, Stack);
    Stack.push(x);
}

void Graph::CTC()
{
    stack<int> Stack;
    
    int k = 0;
    
    bool *visited = new bool[N];
    for(int i = 0; i < N; i++)
        visited[i] = false;
    
    for(int i = 0; i < N; i++)
        if(visited[i] == false)
            Order(i, visited, Stack);
            
    Graph gr = tr();
    
    for(int i = 0; i < N; i++)
        visited[i] = false;
    
    while(Stack.empty() == false)
    {
        int x = Stack.top();
        Stack.pop();
    
        if(visited[x] == false)
        {
            gr.DFS(x, visited);
            k++;
            s++;
            t = 0;
        }
    }
    
    g<<k;
    g<<endl;
    for(int j = 0; j < s; j++)
        {for(int l = 0; l < u; l++)
        if(a[j][l] != -1)
            g<<a[j][l] + 1<<" ";
         g<<endl;   
        }
}

int main()
{
    int N, M, x, y;
    f>>N>>M;
    Graph gr(N);
    
    std::fill(*a, *a + 2001*2001, -1);
    
    for(int i = 0; i < M; i++)
    {
        f>>x>>y;
        x -= 1;
        y -= 1;
        gr.addEdge(x, y);
    }

 
    gr.CTC();
}