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


using namespace std;

// Kosaraju

void dfs(int node, vector<bool>& visited, const vector<vector<int>>& graph, stack<int>& DFS){
    visited[node] = true;
    for(auto adjacent : graph[node])
        if(!visited[adjacent])
            dfs(adjacent, visited, graph, DFS);
    DFS.push(node);
}

void transposed_dfs(int node, vector<bool>& visited, const vector<vector<int>>& transposed_graph, vector<vector<int>>& components){

    visited[node] = true;
    components[components.size() - 1].push_back(node);

    for(auto adjacent : transposed_graph[node])
        if(!visited[adjacent])
            transposed_dfs(adjacent, visited, transposed_graph, components);
}

int main()
{
    ifstream cin("ctc.in");
    ofstream cout("ctc.out");
         

    int N, M;
    cin >> N >> M;

    vector<vector<int>> graph, transposed_graph;
    vector<bool> visited;
    for(int i = 0; i < N; ++i){
        visited.push_back(false);
        graph.push_back({});
        transposed_graph.push_back({});
    }

    for(int x, y; M > 0; --M){

        cin >> x >> y;
        --x; --y;
        graph[x].push_back(y);
        transposed_graph[y].push_back(x);
    }

    stack<int> DFS;

    for(int i = 0; i < N; ++i)
        if(!visited[i])
            dfs(i, visited, graph, DFS);
   
    vector<vector<int>> components;
    fill(visited.begin(), visited.end(), false);

    while(!DFS.empty()){
        while(!DFS.empty() && visited[DFS.top()])
            DFS.pop();

        if(!DFS.empty()){
            components.push_back({});
            transposed_dfs(DFS.top(), visited, transposed_graph, components);
            DFS.pop();
        }
    }

    cout << components.size() << "\n";
    for(auto component : components){
        for(auto component_member : component)
            cout << component_member + 1 << " ";

        cout << "\n";
    }


    cin.close();
    cout.close();

    return 0;
}