#include <iostream>
#include <fstream>
#include <bits/stdc++.h>

#define nmax 100010

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

vector <int> la[nmax], conex[nmax];
int indx[nmax], viz[nmax]={0}, dmin[nmax], i=0, nr=0;
stack<int> s;


void Tarjan(int nod){

    indx[nod] = i;
    dmin[nod] = i;
    viz[nod] = 1;
    i++;
    s.push(nod);

    // Pentru fiecare vecin nevizitat al nodului curent se apeleaza recursiv Tarjan
    for(int j=0; j<la[nod].size(); j++){
        if(indx[la[nod][j]]==-1){
            Tarjan(la[nod][j]);
            dmin[nod]=min(dmin[nod], dmin[la[nod][j]]);
        }
    // Daca vecinul a fost deja vizitat, actualizam distanta minima (exista drum de intoarcere in arborele DFS)
        else if(viz[la[nod][j]]==1){
            dmin[nod]=min(dmin[nod], indx[la[nod][j]]);
        }
    }

    if(indx[nod]==dmin[nod]){
        int n;
        nr++;
        do{
            n=s.top();
            s.pop();
            viz[n]=0;
            conex[nr].push_back(n);

        }while(n!=nod);
    }
}


int main()
{   int n,m,x,y;
    f>>n>>m;

    // Se introduc muchiile in liste de adiacenta
    for(int i=1; i<=m; i++){
        f>>x>>y;
        la[x].push_back(y);
    }
    // Vectorul indx tine ordinea in care sunt vizitate nodurile intr-o parcurgere DFS
    memset(indx, -1, sizeof(indx));
    // Vectorul dmin tine distanta minima fata de radacina arborelui DFS
    memset(dmin, -1, sizeof(dmin));

    // Pentru fiecare nod nevizitat se aplica algoritmul Tarjan
    for(int j=1; j<=n; j++){
        if(indx[j]==-1){
            Tarjan(j);
        }
    }

    g<<nr<<"\n";
    for(int k=1; k<=nr; k++){
        for(int l=0; l<conex[k].size(); l++){
            g<<conex[k][l]<<" ";
        }
        g<<"\n";
    }

    f.close();
    g.close();
    return 0;
}