//1
/*
#include<bits/stdc++.h>
using namespace std;

vector<int> albe;
vector<int> negre;

int bfs(vector<vector<int>>& adi,vector<int>& culoare, int nod) {
    queue<int> coada;
    coada.push(nod);
    if(culoare[nod]==-1)
        culoare[nod]=1;
        
    while(!coada.empty()) {
        int cap=coada.front();
        coada.pop();
        for(auto index:adi[cap]) {
            if(culoare[index]==-1) {
                culoare[index]=1-culoare[cap];
                coada.push(index);
            }
            else if(culoare[index]==culoare[cap])
                return false;

            if (culoare[index] == 0) {
                    albe.push_back(index);
                } else {
                    if (culoare[index] ==1 ) negre.push_back(index);
                }
        }
    }
    return true;
}

bool possibleBipartition(int n, vector<vector<int>>& dislikes) {
    vector<vector<int>> adi(n+1);
    vector<int> culoare(n+1,-1);

    for(auto index:dislikes) {
        adi[index[0]].push_back(index[1]);
        adi[index[1]].push_back(index[0]);
    }
        
    for(int i=0; i<n; i++) {
        if(culoare[i]==-1)
            if(!bfs(adi,culoare,i))
                return false;
               
    }
    return true;
}

void afisareCulori(int n, vector<vector<int>>& dislikes) {
    if (possibleBipartition(n, dislikes)) {
        for ( auto index:albe) {
            cout << albe[index] << " ";
        }
        cout << endl;

        for ( auto index:negre) {
            cout << negre[index] << " ";
        }
    }
}

int main () {
    vector<vector<int>> dislikes = {{1,2},{1,3},{2,4}};
    int n=4;
    cout << possibleBipartition(n, dislikes);
    afisareCulori(n, dislikes);
    return 0;
}
*/

//2
/*
#include <bits/stdc++.h>

using namespace std;

vector<int> vecDfs;
vector<vector<int>> adi(50000); //avem nev de spatiu, altfel segm fault
vector<int> vizitat(50000); 
vector<int> P;
vector<int> poz(50000);

void dfs (int nod) {
    vizitat[nod] = 1;
    vecDfs.push_back(nod);

    for ( int i=0; i<adi[nod].size(); i++ ) {
        if (vizitat[adi[nod][i]] == 0) 
            dfs(adi[nod][i]);
    }
}

bool checkOK (int n) {
    for ( int i=0; i<n; i++ ) {
        if ( vecDfs[i] != P[i] )
            return 0;
    }

    return 1;
}

bool met_sort (int prim_nod, int sec_nod) {     //conditie pentru sortarea implicita
    return poz[prim_nod] < poz[sec_nod];
}

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

    cin >> n >> m;

    for ( int i=1; i<=n; i++ ) {
        cin >> x;
        poz[x] = i;
        P.push_back(x);
    }

    for ( int i=1; i<=m; i++ ) {
        cin >> x >> y;
        adi[x].push_back(y);
        adi[y].push_back(x);
    }

    for (int i = 1; i <= n; i++) {
        sort(adi[i].begin(), adi[i].end(), met_sort);
    }

    dfs(1);

    cout << checkOK(n);
    return 0;

}
*/
//3 

#include <bits/stdc++.h>

using namespace std;

int n, nrconex;
//construim o matrice in care retinem nodurile pe care le contine fiecare componenta conexa
vector <vector <int>> adif;

vector <vector <int>> adi1; //lista adiacenta
vector <vector <int>> adi2; //lista adiacenta inversa

vector <int> vizitat;
stack <int> stiva;

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

void dfs_1 (int nod) {
    for(auto i=0; i < adi1[nod].size();i++)
    {
        if(vizitat[adi1[nod][i]]==0)
        {
            vizitat[adi1[nod][i]]=1;
            dfs_1(adi1[nod][i]);
        }
    }
    // introducem nodurile vizitate in dfs 1 intr-o stiva pentru a putea aplica apoi dfs 2
    stiva.push(nod);
}

void dfs_2 (int nod) {
    //intrucat nodul a fost vizitat in ambele dfs, vom atribui valoarea 2 in vectorul vizitat
    vizitat[nod] = 2;

    //vom adauga nodul in componenta conexa
    adif[nrconex].push_back(nod);

    //parcurgem vecinii nodului curent. Daca acestia au fost vizitate in dfs_1, atunci apelam dfs_2
    for( int i=0; i<adi2[nod].size(); i++) {
        if(vizitat[adi2[nod][i]] == 1) {
            dfs_2(adi2[nod][i]);
        }
    }
}


int main () {
    int m, nod, i;
    f>>n>>m;

    adif.resize(n+1);
    vizitat.resize(n+1,0);
    adi1.resize(n+1);
    adi2.resize(n+1);

    //construim cele 2 liste de adiacenta
    for(int i=1; i<=m ; i++) {   
        int a, b;
        f>>a>>b;
        adi1[a].push_back(b);
        adi2[b].push_back(a);
    }

    //parcurgem vectorul in care contorizam daca modurile au fost vizitate sau nu atat in dfs_1 cat si in dfs_2
    for(int i=1; i<=n ; i++) {   //daca nodul nu a fost vizitat, atunci il marcam ca vizitat in dfs_1 si apoi apelam functia dfs_1
        if(vizitat[i] == 0) {
            vizitat[i]=1;
            dfs_1(i);
        }
    }

    //cat timp stiva contine elemente, atunci verificam daca acesta a fost vizitat in dfs_1 si apoi facem dfs_2(parc urgerea in ordine inversa)
    while(stiva.size() > 0) {
        nod = stiva.top();
        stiva.pop();
        if(vizitat[nod]==1) {
            nrconex++;
            dfs_2(nod);
        }
    }

    g << nrconex << endl;

    for( int i=1; i<=nrconex ; i++) {
        for(auto v:adif[i])
        {
            g << v << " ";
        }
        g << endl;
    }

    return 0;
}


//5 
/*
#include <bits/stdc++.h>
using namespace std;

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

//Vom efectua o parcurgere dfs

int matrice[200][200];
vector <int> control;
vector <int> dist(200,INT16_MAX); //valoarea maxima din int


void dfs (int n, int nod, int d) {                    // Distanta de la un nod de control la un alt nod va fi adancimea la care a ajuns dfs-ul

    for(int i=0;i<=n;i++){
        if(matrice[nod][i] ==1 && d+1 < dist[i]){
            dist[i] = d+1;
            dfs(n, i, d+1);
        }
    }
}

//ne intoarcem la nodurile deja parcurse doar daca ajungem la ele printr o distanta mai mica


int main () {
    int n, m, a, b;
    fin>>n>>m;
    for(int i=1;i<=m;i++) {
        fin>>a>>b;
        matrice[a][b]=1;
        matrice[b][a]=1;
    }

    while(fin>>a) {
        control.push_back(a);
    }

    for(int i=0;i<control.size();i++) {
        dist[control[i]] = 0;
        dfs(n,control[i], 0);
    }


    for(int i=1;i<=n;i++) {
        if(dist[i] == INT16_MAX) fout<<-1<<" ";
        else fout<<dist[i]<<" ";
    }

    return 0;
}
*/