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

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

struct componente_conexe
{
    int radacina,indice_componente;
    componente_conexe(int radacina=0, int indice_componente=0):
        radacina(radacina),indice_componente(indice_componente)
        {
        }
};

int n,m,nr_componente;

vector<vector<int> >afara,inauntru;

vector<vector<int> >componente; //compoente[i] va contine a i-a componenta conexa

vector<componente_conexe>v;

stack<int> s;

vector<bool>vizitat,componenta_conexa;

void citire()
{
    int i,x,y;
    fin>>n>>m;
    afara.resize(n+2);
    inauntru.resize(n+2);
    vizitat.resize(n+2);
    componente.resize(n+2);
    componenta_conexa.resize(n+2);
    v.reserve(n+2);
    for(i=1;i<=m;i++)
    {
        fin>>x>>y;
        afara[x].push_back(y);
        inauntru[y].push_back(x);
    }
}

void parcurgere(int nod)
{
    vector<int>::iterator it;
    vizitat[nod]=1;
    for(it=afara[nod].begin();it!=afara[nod].end();it++)
    {
        if(!vizitat[*it])
            parcurgere(*it);
    }
    s.push(nod);

}

void alocare_componenta(int nod, int radacina, int nr_componenta)
{
    vector<int>::iterator it;
    componenta_conexa[nod]=1;
    componente[nr_componenta].push_back(nod);
    for(it=inauntru[nod].begin();it!=inauntru[nod].end();it++)
    {
        if(!componenta_conexa[*it])
        {
            alocare_componenta(*it,radacina,nr_componenta);
        }
    }
}

void afisare_componenta(int nr_componenta)
{
    vector<int>::iterator it;
    for(it=componente[nr_componenta].begin();it!=componente[nr_componenta].end();it++)
    {
        fout<<*it<<' ';
    }
    fout<<'\n';
}
void afisare()
{
    int i;
    fout<<nr_componente<<'\n';
    for(i=0;i<nr_componente;i++)
    {
        afisare_componenta(v[i].indice_componente);
    }
}
void rezolvare()
{
    int i,x;
    for(i=1;i<=n;i++)
    {
        if(!vizitat[i])
        {
            parcurgere(i);
        }
    }
    while(!s.empty())
    {
        x=s.top();
        if(!componenta_conexa[x])
        {
            nr_componente++;
            v.push_back(componente_conexe(x,nr_componente));
            alocare_componenta(x,x,nr_componente);
        }
        s.pop();
    }
    afisare();
}
int main()
{
    citire();
    rezolvare();
    return 0;
}