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

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

const int MAX_N = 100000;

int n, m;
std::vector<int> g1[MAX_N + 1];
std::vector<int> g2[MAX_N + 1];

void read() {
    fin >> n >> m;
    for (int i = 1; i <= m; i++) {
        int u, v;
        fin >> u >> v;
        g1[u].push_back(v);
        g2[v].push_back(u);
    }
}

bool vis[MAX_N + 1];
std::stack<int> stk;

void dfs1(int node) {
    vis[node] = true;
    for (int to : g1[node])
        if (!vis[to])
            dfs1(to);
    stk.push(node);
}

std::vector<int> comp;
std::vector<std::vector<int>> comps;
int id[MAX_N + 1], cnt;

void dfs2(int node) {
    id[node] = cnt;
    vis[node] = true;
    comp.push_back(node);
    for (int to : g2[node])
        if (!vis[to])
            dfs2(to);
}

void solve() {
    for (int i = 1; i <= n; i++)
        if (!vis[i])
            dfs1(i);

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

    while (!stk.empty()) {
        int node = stk.top();
        stk.pop();

        if (vis[node])
            continue;

        comp.clear();
        cnt++;
        dfs2(node);

        comps.push_back(comp);
    }

    for (int i = 1; i <= n; i++) {
        for (int j : g1[i]) {
            assert(id[i] <= id[j]);
        }
    }

    fout << comps.size() << '\n';

    for (const auto & comp : comps) {
        for (int x : comp)
            fout << x << ' ';
        fout << '\n';
    }
}

int main() {
    read();
    solve();
    return 0;
}