#include <iostream>
#include <vector>
#include <stack>

#define NMax 100005

using namespace std;

vector <int> G[NMax];
int N, CIndex, Index[NMax], LowestI[NMax];
stack <int> Stack;
bool InStack[NMax];
vector < vector <int> > CTC;

void Read ()
{
    freopen ("ctc.in", "r", stdin);
    int M;
    scanf ("%d %d", &N, &M);
    for (; M>0; --M)
    {
        int X, Y;
        scanf ("%d %d", &X, &Y);
        G[X].push_back (Y);
    }
}

void Print ()
{
    freopen ("ctc.out", "w", stdout);
    printf ("%d\n", CTC.size ());
    for (unsigned i=0; i<CTC.size (); ++i)
    {
        for (unsigned j=0; j<CTC[i].size (); ++j)
        {
            printf ("%d ", CTC[i][j]);
        }
        printf ("\n");
    }
}

inline int Min (int a, int b)
{
    if (a<b)
    {
        return a;
    }
    return b;
}

void DetCTC (int X)
{
    vector <int> C;
    int Y;
    do
    {
        Y=Stack.top ();
        Stack.pop ();
        InStack[Y]=false;
        C.push_back (Y);
    }
    while (X!=Y);
    CTC.push_back (C);
}

void Tarjan (int X)
{
    ++CIndex;
    if (Index[X]==0)
    {
        Index[X]=LowestI[X]=CIndex;
    }
    Stack.push (X);
    InStack[X]=true;
    for (unsigned v=0; v<G[X].size (); ++v)
    {
        int V=G[X][v];
        if (Index[V]==0)
        {
            Tarjan (V);
            LowestI[X]=Min (LowestI[X], LowestI[V]);
        }
        else
        {
            if (InStack[V])
            {
                LowestI[X]=Min (LowestI[X], LowestI[V]);
            }
        }
    }
    if (Index[X]==LowestI[X])
    {
        DetCTC (X);
    }
}

int main()
{
    Read ();
    for (int i=1; i<=N; ++i)
    {
        if (Index[i]==0)
        {
            Tarjan (i);
        }
    }
    Print ();
    return 0;
}