#include <iostream>
#include <fstream>
#include <vector>
#include <queue>

#define Nmax 100005

using namespace std;

ifstream fin("ctc.in");
ofstream fout("ctc.out");

vector<int> ctc[Nmax];
int N, M;
bool vizitatDFS[Nmax], vizitatDFSt[Nmax];   // pentru DFS pe grafurile initial si transpus
vector<int> graf_transpus[Nmax];
// stiva pentru memorarea nodurilor in ordinea timpilor de final
int S[Nmax], top;

class Graf{
private:
    int Nr_Noduri, Nr_Muchii;
    vector<int> matrice_adiacenta[Nmax];
    // vector<int> muchii[Nmax], muchiit[Nmax];

public:
    Graf(int N, int M); // constructor
    /*
    vector < vector<int> > getMatriceAdiacenta()
    {
        return matrice_adiacenta;
    }
    */
    void Citire_Graf_Orientat();
    void DFS(int nod);
    void DFS_transpus(int nod, int ct);
    void CTC();
    void Graf_Transpus();
    void Parcurgere();
};

// constructor
Graf :: Graf(int N, int M)
{
    Nr_Noduri = N;
    Nr_Muchii = M;
    // matrice_adiacenta = matrice;
}

void Graf :: Citire_Graf_Orientat()
{
    for ( int i = 1; i <= Nr_Muchii; i++ )
    {
        int x, y;
        fin >> x >> y;
        matrice_adiacenta[x].push_back(y);
        graf_transpus[y].push_back(x);
    }
}

void Graf :: DFS(int nod)
{
    vizitatDFS[nod] = 1;

    for ( int i = 0; i < matrice_adiacenta[nod].size(); i++ )
        if ( !vizitatDFS[i] )
            DFS(i);

    // pentru nodul x putem stabili timpul de finalizare si il memoram in stiva
    S[++top] = nod;    
}

// stabilim timpul de finalizare pentru fiecare nod
void Graf :: Parcurgere()   // cel initial
{
    for ( int i = 1; i <= Nr_Noduri; i++ )
        if ( ! vizitatDFS[i] )
            DFS(i);
}

void Graf :: DFS_transpus(int nod, int ct)
{
    vizitatDFSt[nod] = 1;
    ctc[ct].push_back(nod);

    for ( int i = 0; i < graf_transpus[nod].size(); i++ )
        if ( !vizitatDFSt[i] )
            DFS_transpus(i, ct);
}

void Graf :: CTC()
{
    int ct_comp = 0;

    while( top )
    {
        if( !vizitatDFSt[S[top]] )
        {
            ct_comp ++;
            DFS_transpus(S[top], ct_comp);  // DFS in graful transpus
        }
        top--;
    }
 
    fout << ct_comp << "\n";
 
    for ( int i = 1; i <= ct_comp; i++ )
    {
        for( int j = 0; j < ctc[i].size(); j++ )
                fout << j << " ";
        fout << "\n";
    }
}

int main()
{
    fin >> N >> M;
    Graf G(N, M);
    G.Citire_Graf_Orientat();
    G.Parcurgere();
    G.CTC();

    return 0;
}