#include <iostream>
#include <vector>
#include <queue>
#include <fstream>
#include <stack>
using namespace std;
#define Nmax 100005
#define Rezolvare 3

const char iname[] = "ctc.in";
const char oname[] = "ctc.out";


vector<int> rev[Nmax];
ifstream f(iname);
ofstream g(oname);
class Graph{
public:
    Graph(int n, int m);
    ~Graph();
    virtual void add_muchie(int x, int y){}
private:

protected:
    vector<int> la[Nmax]; //lista de adiacenta;
    int n,m; //numarul de noduri si numarul de muchii
};

class Undirected: public Graph{
public:
     Undirected(int n, int m);
     ~Undirected();
     void add_muchie(int x,int y)
     {
         la[x].push_back(y);
         la[y].push_back(x);
     }
     void dfs(int start,int visited[]);

private:

};
int nr_conex=0;
void Undirected::dfs(int start,int visited[])
{
  visited[start] = nr_conex;
  for(auto i:la[start])
  {
      if(!visited[i])
        dfs(i,visited);
  }
}
 Undirected::Undirected(int n, int m): Graph(n,m)
{

}
Undirected::~Undirected()
{

}
class Directed: public Graph{
public:
     Directed(int n,int m);
     ~Directed();
     void add_muchie(int x,int y);
     void bfs(int start, int visited[],int dist[]);
     void dfs_plus(int i,stack<int> &my_stack,int visited[])
     {
         visited[i]=1;
         for(int j:la[i])
         {
             if(!visited[j])
                dfs_plus(j,my_stack,visited);
         }
         my_stack.push(i);
     }
    void reverse()
    {
    for(int i=1;i<=n;i++)
    {
        for(int j:la[i])
            rev[j].push_back(i);
    }
    }
    void dfs(int i,int visited[])
    {
        g<<i<<" ";
        visited[i]=1;
        for(auto j:rev[i])
        {
            if(!visited[j])
                dfs(j,visited);
        }
    }


     void findCTC()
     {
         int visited[n];
         for(int i=1;i<=n;i++)
            visited[i]=0;

         stack<int> my_stack;
         for(int i=1;i<=n;i++)
            if(!visited[i])
                dfs_plus(i,my_stack,visited);

         reverse();

         for(int i=1;i<=n;i++)
            visited[i]=0;

         while(!my_stack.empty())
         {
             int cur = my_stack.top();
             my_stack.pop();

             for(int cur=1;cur<=n;cur++)
                if(!visited[cur])
                {
                    dfs(cur,visited);
                    g<<'\n';
                }
         }
     }

private:

};

Directed::Directed(int n, int m): Graph(n,m)
{

}
Directed::~Directed()
{

}
void Directed::add_muchie(int x,int y)
{
    la[x].push_back(y);
}

void Directed::bfs(int start, int visited[],int dist[]){
    queue <int> coada;
    visited[start]=true;
    coada.push(start);
    dist[start] = 0;
    while(!coada.empty())
    {   start = coada.front();
        coada.pop();
        for(auto i:la[start])
        {
            if(!visited[i])
            {
                visited[i] = true;
                coada.push(i);
                dist[i]=dist[start]+1;
            }
        }
    }
}
Graph::Graph(int n=0, int m=0):n(n),m(m)
{

}
Graph::~Graph()
{

}



int main()
{
    int n,m,s;
    int x,y;
    switch(Rezolvare)
    {

    case 1:
    {
     f>>n>>m>>s;
     Directed grf(n,m);
     for(int i=0;i<m;i++)
     {
      f>>x>>y;
      grf.add_muchie(x,y);
     }
     f.close();
     int visited[n],dist[n];
     for(int i=0;i<=n;i++)
        visited[i]=dist[i]=0;
     grf.bfs(s,visited,dist);
     for(int i=1;i<=n;i++)
     {
         if(visited[i])
            g<<dist[i]<<" ";
        else g<<-1<<" ";
     }
        break;
    }
    case 2:
    {
     f>>n>>m;
     Undirected grf(n,m);
     int visited[n];
     for(int i=0;i<m;i++)
      {
      f>>x>>y;
      grf.add_muchie(x,y);
      }
     for(int i=0;i<=n;i++)
        visited[i]=0;
       for(int i=1;i<=n;i++)
        if(!visited[i])
         {
             nr_conex++;
             grf.dfs(i,visited);
         }
    g<<nr_conex;
    break;
    }
    case 3:
    {

     f>>n>>m;
     Directed grf(n,m);

     for(int i=0;i<m;i++)
     {
         f>>x>>y;
         grf.add_muchie(x,y);
     }
     grf.findCTC();
     break;
    }
    }
    return 0;
}