#include <iostream>
#include <fstream>
#include <list>
#include <queue>
#include <stack>
using namespace std;

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

class grafuri_orientate
{
    unsigned int numar_noduri;
    list <int > *lista;
    list <int> *revlista;
    public:
    grafuri_orientate(unsigned int a=0) //Constructorul
        {
            numar_noduri=a;
            lista=new list<int> [a+1];
            revlista=new list <int> [a+1];
        };

    friend istream & operator >>( istream& i, grafuri_orientate & A);
    bool get_data_graf();
    bool parcurgere_in_latime(int nod,int afis);
    bool parcurgere_in_adancime(int nod);
    bool parcurgere(int nod,bool visited[], stack <int> &sol);
    bool dfs_reverse(int nod, bool *visited, list <int> *&a,int nr);
    list <int> * componente_tare_conexe();
    bool matricea_drumurilor();
};

int main()
{
    grafuri_orientate A;
    f>>A;
    A.componente_tare_conexe();
    return 0;
}



std:: istream & operator >>(std:: istream & i,  grafuri_orientate & A)
{
    unsigned m;
    i>>A.numar_noduri;
    i>>m;
    A.lista=new list <int> [A.numar_noduri+1];
    A.revlista=new list <int> [A.numar_noduri+1];
    for(unsigned int l=1;l<=m;l++)
    {
        int x,y;
        i>>x>>y;
        A.lista[x].push_back(y);
        A.revlista[y].push_back(x);

    }
    return i;
}

bool grafuri_orientate:: parcurgere_in_latime( int nod,int afis)
{
    queue <int> coada;
    bool visited[numar_noduri+1];
    for(unsigned int i=0;i<=numar_noduri+1;i++) visited[i]=0;

    coada.push(nod);
    visited[nod]=1;

    while(!coada.empty())
    {
        int k=coada.front();
        if(afis==1)
        g<<k<<" ";
        for(list <int>:: iterator it=lista[k].begin();it!=lista[k].end();it++)
        if(visited[*it]==0)
        {
            coada.push(*it);
            visited[*it]=1;
        }
        coada.pop();
    }
    if(afis==0)
        {for(unsigned int i=1;i<=numar_noduri;++i)
        g<<visited[i]<<" ";
        g<<"\n";
        }
    return 1;
}
bool grafuri_orientate:: parcurgere(int nod,bool visited[],stack <int> &sol)
{
    visited[nod]=1;
    for(list <int> :: iterator it=lista[nod].begin();it!=lista[nod].end();++it)
    if(visited[*it]==0)
        {
            parcurgere(*it,visited,sol);
        }

   sol.push(nod);
    return 1;
}

bool grafuri_orientate:: parcurgere_in_adancime(int nod)
{
    bool visited[numar_noduri+1];
    stack <int> sol,solrev;
    for(unsigned int i=1;i<=numar_noduri;i++) visited[i]=0;
    for(unsigned int i=1;i<=numar_noduri;++i)
    if(visited[i]==0)
     {parcurgere(i,visited,sol);
     }
    while(!sol.empty()){ solrev.push(sol.top());sol.pop();}
    while(!solrev.empty()){g<<solrev.top();solrev.pop();}
    return 1;
}


bool grafuri_orientate::get_data_graf()
{
    g<<"Graful are: "<<this->numar_noduri<<" noduri\n";
    for(unsigned int i=1;i<=this->numar_noduri;i++)
    {
        for(list <int> ::iterator it=this->lista[i].begin();it!=this->lista[i].end();it++)
        g<<*it<<" ";
        g<<"\n";
    }

    g<<"GRAFUL INVERSAT:";
        for(unsigned int i=1;i<=this->numar_noduri;i++)
    {
        for(list <int> ::iterator it=this->revlista[i].begin();it!=this->revlista[i].end();it++)
        g<<*it<<" ";
        g<<"\n";
    }
    return 1;
}


bool grafuri_orientate::dfs_reverse(int nod, bool *visited, list <int> *&a,int nr)
{
    visited[nod]=0;
    for(list <int> :: iterator it=revlista[nod].begin();it!=revlista[nod].end();++it)
    if(visited[*it]==1)
    {
        dfs_reverse(*it,visited,a,nr);
    }
    a[nr].push_back(nod);
    return 1;
}

list <int> * grafuri_orientate:: componente_tare_conexe()
{
    stack <int> sol;
    int nur=0;
    bool visited[numar_noduri+1];
    list <int> *solutii; solutii=new list <int> [numar_noduri+1];
    for(unsigned int i=1;i<=numar_noduri;++i) visited[i]=0;
    for(unsigned int i=1;i<=numar_noduri;++i)
    if(visited[i]==0)
    parcurgere(i,visited,sol);
     while(!sol.empty())
         {if(visited[sol.top()]==1)
         {

             nur++;
            dfs_reverse(sol.top(),visited,solutii,nur);

         }
         sol.pop();
         }

     g<<nur<<"\n";
     for(int i=1;i<=nur;++i)
     {
         for(list <int> :: iterator it=solutii[i].begin();it!=solutii[i].end();++it)
         g<<*it<<" ";
         g<<"\n";
         }
     return solutii;
}

bool grafuri_orientate:: matricea_drumurilor()
{
    for(unsigned int i=1;i<=numar_noduri;++i)
        parcurgere_in_latime(i,0);
    return 1;
}