//Folosim algoritmul lui Koseraju (2dfs): O(n+m)

#include <iostream>
#include <fstream>
#include <stack>
#include <vector>

using namespace std;

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

int n, m, nrcomp = 0;
stack <int> s;
vector <vector<int>> graf, transpus, ctc;
vector <bool> vizitat;

void dfs1(int nod)
{
    vizitat[nod] = true;

    for(auto vecin : graf[nod])
    {
        if(!vizitat[vecin])
            dfs1(vecin);
    }

    s.push(nod);
}

void dfs2(int nod)
{
    vizitat[nod] = true;

    for(auto vecin : transpus[nod])
    {
        if(!vizitat[vecin])
            dfs2(vecin);
    }

    ctc[nrcomp].push_back(nod);
}



int main()
{
    int a, b, i;

    f >> n >> m;

    graf.resize(n+1);
    transpus.resize(n+1);
    vizitat.resize(n+1, false);
    ctc.resize(n+1);

    for(i = 1; i <= m; i++)
    {
        f >> a >> b;
        graf[a].push_back(b);
        transpus[b].push_back(a);
    }

    for(i = 1; i <= n; i++)
    {
        if(!vizitat[i])
            dfs1(i);
    }

    for(i = 1; i <= n; i++)
        vizitat[i] = false;

    nrcomp = 0;

    while(!s.empty())
    {
        int ind = s.top();
        s.pop();

        if(!vizitat[ind])
        {
            nrcomp++;
            dfs2(ind);
        }
    }

    g << nrcomp << '\n';

    for(i = 1; i <= nrcomp; i++)
    {
        for(auto nod : ctc[i])
            g << nod << ' ';
        g << '\n';
    }

    return 0;
}