#include<iostream>

 #include<cstring>

 #include<cmath>

 #include<cstdlib>

 #include<cstdio>

 #include<algorithm>

 #include<string.h>

 using namespace std;

 struct node {

     int v,next;

 }edge[];

 int DFN[],LOW[];

 int stack[],heads[],visit[],cnt,tot,index;

 void add(int x,int y)

 {

      edge[++cnt].next=heads[x];

      edge[cnt].v = y;

      heads[x]=cnt;

      return ;

  }

 void tarjan(int x)//代表第几个点在处理。递归的是点。

 {

      DFN[x]=LOW[x]=++tot;// 新进点的初始化。

      stack[++index]=x;//进站

      visit[x]=;//表示在栈里

      for(int i=heads[x];i!=-;i=edge[i].next)

      {

          if(!DFN[edge[i].v]) {//如果没访问过

              tarjan(edge[i].v);//往下进行延伸，开始递归

              LOW[x]=min(LOW[x],LOW[edge[i].v]);//递归出来，比较谁是谁的儿子／父亲，就是树的对应关系，涉及到强连通分量子树最小根的事情。

          }

          else if(visit[edge[i].v ]){  //如果访问过，并且还在栈里。

              LOW[x]=min(LOW[x],DFN[edge[i].v]);//比较谁是谁的儿子／父亲。就是链接对应关系

          }

      }

      if(LOW[x]==DFN[x]) //发现是整个强连通分量子树里的最小根。

      {

          do{

              printf("%d ",stack[index]);

              visit[stack[index]]=;

              index--;

          }while(x!=stack[index+]);//出栈，并且输出。

          printf("\n");

      }

      return ;

 }

 int main()

 {

      memset(heads,-,sizeof(heads));

      int n,m;

      scanf("%d%d",&n,&m);

      int x,y;

      for(int i=;i<=m;i++)

      {

          scanf("%d%d",&x,&y);

         add(x,y);

      }

      for(int i=;i<=n;i++)

          if(!DFN[i])  tarjan(i);//当这个点没有访问过，就从此点开始。防止图没走完

      return ;

 }

 #include<iostream>

 #include<algorithm>

 #include<cstring>

 #include<queue>

 #include<stack>

 #define maxn 1005

 using namespace std;

 struct Edge

 {

     int next;

     int to;

 }edge[maxn];

 int head[maxn];

 int cnt;

 int step;

 int dfn[maxn];//表示深搜的步数；

 int low[maxn];//表示能追溯到最早的栈中节点的次序；

 int sccno[maxn];//缩点数组，表示每个点对应的缩点值；

 int scc_cnt;//强连通分量的个数；

 void init()

 {

     cnt=;

     step=;

     memset(head,-,sizeof(head));

 }

 void add(int u,int v)

 {

     edge[cnt].next=head[u];

     edge[cnt].to=v;

     head[u]=cnt++;

 }

 vector<int>scc[maxn];//得出来的缩点，保存具体缩了那些点；

 stack<int>s;

 void dfs(int u)

 {

     dfn[u]=low[u]=++step;

     s.push(u);

     for(int i=head[u];i!=-;i=edge[i].next)

     {

         int v=edge[i].to;

         if(!dfn[v])

         {

             dfs(v);

             low[u]=min(low[u],low[v]);

         }

         else if(!sccno[v])

         {

             low[u]=min(low[u],dfn[v]);

         }

     }

     if(low[u]==dfn[u])

     {

         scc_cnt++;

         scc[scc_cnt].clear();

         while()

         {

             int x=s.top();

             s.pop();

             if(sccno[x]!=scc_cnt)

                 scc[scc_cnt].push_back(x);

             sccno[x]=scc_cnt;

             if(x==u)

                 break;

         }

     }

 }

 void tarjan(int n)

 {

     memset(sccno,,sizeof(sccno));

     memset(dfn,,sizeof(dfn));

     step=scc_cnt=;

     for(int i=;i<=n;i++)

         if(!dfn[i])dfs(i);

 }

 int main()

 {

     int n,m;

     int x,y;

     cin>>n>>m;

     init();

     while(m--)

     {

         cin>>x>>y;

         add(x,y);

     }

     tarjan(n);

     cout<<scc_cnt<<endl;

     return ;

 }