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

using namespace std;

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

int n, m;
vector<vector<int>> g, gt;
stack<int> nodes;
vector<int> viz;

void dfs_iterative(int start) {
  vector<int> index(n + 1, 0);
  stack<int> st;
  st.push(start);
  viz[start] = 1;

  while (!st.empty()) {
    int s = st.top();
    if (index[s] < g[s].size()) {
      int neigh = g[s][index[s]];
      index[s]++;
      if (!viz[neigh]) {
        viz[neigh] = 1;
        st.push(neigh);
      }
    } else {
      st.pop();
      nodes.push(s);
    }
  }
}

void create_gt() {
  gt.resize(n + 1);
  for (int i = 1; i <= n; i++) {
    for (auto y : g[i]) {
      gt[y].push_back(i);
    }
  }
}

void ctc_iterative(int start, int count) {
  vector<int> index(n + 1, 0);
  stack<int> st;
  st.push(start);
  viz[start] = count;

  while (!st.empty()) {
    int s = st.top();
    if (index[s] < gt[s].size()) {
      int neigh = gt[s][index[s]];
      index[s]++;
      if (!viz[neigh]) {
        viz[neigh] = count;
        st.push(neigh);
      }
    } else {
      st.pop();
    }
  }
}

int main() {
  fin >> n >> m;

  g.resize(n + 1);
  viz.resize(n + 1, 0);

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

  for (int i = 1; i <= n; i++) {
    if (!viz[i]) {
      dfs_iterative(i);
    }
  }

  fill(viz.begin(), viz.end(), 0);
  create_gt();

  int count = 1;
  while (!nodes.empty()) {
    int start = nodes.top();
    nodes.pop();
    if (!viz[start]) {
      ctc_iterative(start, count);
      count++;
    }
  }

  vector<vector<int>> components(count);
  for (int i = 1; i <= n; i++) {
    components[viz[i]].push_back(i);
  }

  fout << count - 1 << '\n';
  for (int i = 1; i < count; i++) {
    for (int node : components[i]) {
      fout << node << " ";
    }
    fout << '\n';
  }

  return 0;
}