///n**2 * log*(n): calcul toate ciclurile simple + DSU pe componentele ciclilor.
#include <bits/stdc++.h>
#define aaa system("read -r -p \"Press enter to continue...\" key");
#define dbg(x) std::cerr<<(#x)<<": "<<(x)<<'\n',aaa
#define dbga(x,n) std::cerr<<(#x)<<"[]: ";for(int _=0;_<n;_++)std::cerr<<x[_]<<' ';std::cerr<<'\n',aaa
#define dbgs(x) std::cerr<<(#x)<<"[stl]: ";for(auto _:x)std::cerr<<_<<' ';std::cerr<<'\n',aaa
#define dbgp(x) std::cerr<<(#x)<<": "<<x.first<<' '<<x.second<<'\n',aaa
#define dbgsp(x) std::cerr<<(#x)<<"[stl pair]:\n";for(auto _:x)std::cerr<<_.first<<' '<<_.second<<'\n';aaa

const int maxn = 100'000;

struct DSU {
    int n;
    std::vector<int> dad, size;

    DSU(int n) {
        this->n = n;
        dad.resize(n+1); std::iota(dad.begin(), dad.end(), 0);
        size.resize(n+1, 1);
    }

    int get_root(int z) {
        int r = z, aux;
        while (dad[r] != r) r = dad[r];
        while (z != r) {
            aux = dad[z];
            dad[z] = r;
            z = aux;
        }
        return r;
    }

    void unite(int a, int b) {
        a = get_root(a); b = get_root(b);
        if (a == b) return;
        if (size[a] < size[b]) std::swap(a, b);
        dad[b] = a;
        size[a] += size[b];
        size[b] = 0;
    }
};

std::vector<int> g[maxn+1];
std::vector<int> ctcs[maxn+1];
bool viz[maxn+1], inchain[maxn+1];
std::vector<int> chain;

void dfs(DSU &dsu, int nod) {
    viz[nod] = true;
    inchain[nod] = true;
    chain.push_back(nod);

    for (int nn: g[nod]) {
        if (!viz[nn]) dfs(dsu, nn);
        else if (nn != nod && inchain[nn]) { ///unesc tot ce am pe lantul simplu.
            int z = (int)chain.size() - 2;
            while (z > 0 && chain[z] != nn) {
                dsu.unite(chain[z], chain[z+1]);
                z--;
            }

            dsu.unite(chain[z], chain[z+1]);
        }
    }

    inchain[nod] = false;
    chain.pop_back();
}

int main() {
    std::ifstream fin("ctc.in");
    std::ofstream fout("ctc.out");

    int n, m; fin >> n >> m;

    for (int i = 0; i < m; i++) {
        int a, b; fin >> a >> b;
        g[a].push_back(b);
    }

    DSU dsu(n);
    for (int i = 1; i <= n; i++) {
        dfs(dsu, i);
        std::fill(std::begin(viz), std::end(viz), false);
    }

    int cnt_ctcs = 0;
    for (int i = 1; i <= n; i++) {
        int r = dsu.get_root(i);
        ctcs[r].push_back(i);
        if (ctcs[r].size() == 1) cnt_ctcs++;
    }

    fout << cnt_ctcs << '\n';
    for (int i = 1; i <= n; i++) {
        if (!ctcs[i].empty()) {
            for (int z: ctcs[i]) fout << z << ' ';
            fout << '\n';
        }
    }

    return 0;
}