#include <iostream>
#include <fstream>
#include <vector>
#include <queue>

using Graph = std::vector<std::vector<int>>;
using Pq = std::priority_queue<std::pair<int, int>>;

void dfs(const Graph &G,
         int node,
         std::vector<bool> &visited,
         std::vector<int> &st)
{
    visited[node] = true;
    for (auto &neigh : G[node])
        if (!visited[neigh])
            dfs(G, neigh, visited, st);

    st.push_back(node);
}


void dfs_t(const Graph &G, int node, std::vector<bool> &visited,
           std::vector<std::vector<int>> &ret)
{
    visited[node] = true;
    ret.back().push_back(node);

    for (auto &neigh : G[node])
        if (!visited[neigh])
            dfs_t(G, neigh, visited, ret);
}

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

    int N, M;
    fin >> N >> M;

    Graph G(N);
    Graph G_t(N);
    for (auto i = 0; i < M; ++i) {
        int x, y;
        fin >> x >> y;

        G[x - 1].push_back(y - 1);
        G_t[y - 1].push_back(x - 1);
    }

    std::vector<bool> visited(N, false);
    std::vector<int> st;

    for (auto i = 0; i < N; ++i)
        if (!visited[i])
            dfs(G, i, visited, st);

    std::fill(visited.begin(), visited.end(), false);
    std::vector<std::vector<int>> ret;
    auto total = 0;

    for (auto i = N - 1; i >= 0; --i)
        if (!visited[st[i]]) {
            ret.push_back(std::vector<int>());
            dfs_t(G_t, st[i], visited, ret);
            ++total;
        }

    fout << ret.size() << '\n';
    for (auto &comp : ret) {
        for (auto &elem : comp)
            fout << elem + 1 << ' ';
        fout << '\n';
    }

    return 0;
}