#include <fstream>
#include <vector>
#include <algorithm>

#define Nmax 100100
#define Neighbour Graph[Node][i]
#define NeighbourT GraphT[Node][i]

using namespace std;

vector <int> Graph[Nmax], GraphT[Nmax], Component[Nmax];
int N, componentCount, Index, Order[Nmax];
bool used[Nmax];

void Dfs(int Node) {

    used[Node] = false;
    Component[componentCount].push_back(Node);

    for(int i = 0; i < GraphT[Node].size(); i++)
        if(used[NeighbourT])
            Dfs(NeighbourT);

}
void SortTop(int Node) {

    used[Node] = true;

    for(int i = 0; i < Graph[Node].size(); i++)
        if(!used[Neighbour])
            SortTop(Neighbour);

    Order[++Index] = Node;

}
void Solve() {

    for(int i = 1; i <= N; i++)
        if(!used[i])
            SortTop(i);

    reverse(Order + 1, Order + N + 1);

    for(int i = 1; i <= N; i++)
        if(used[Order[i]]) {
            ++componentCount;
            Dfs(Order[i]);
            }

}
void Read() {

    int x, y, M;

    ifstream in("ctc.in");
    in >> N >> M;

    while(M--) {
        in >> x >> y;
        Graph[x].push_back(y);
        GraphT[y].push_back(x);
        }

    in.close();

}
void Write() {

    int i, j;

    ofstream out("ctc.out");
    out << componentCount << '\n';

    for(i = 1; i <= componentCount; i++) {

        for(j = 0; j < Component[i].size(); j++)
            out << Component[i][j] << ' ';

        out << '\n';

        }

    out.close();

}
int main() {

    Read();
    Solve();
    Write();

    return 0;
}