#include <fstream>
#define NMAX 100005
#define INF 10000000

using namespace std;

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

struct nod
{
    int vf;
    struct nod* urm;

};



typedef struct nod*  LSI;

LSI L[NMAX];
nod* p[NMAX];

bool uz[NMAX];

int d[NMAX];

int prim, ultim;

int n, m, start;

void citire();

void inserare(LSI& L, int x, nod* p);

void bfs(int start);

int lg(int y);

int main()

{
    int y;

    citire();

    bfs(start);

    for (y=1; y<=n; y++)

        fout<<lg(y)<<' ';

    return 0;

}

void bfs(int start)

{

    int x;

    int C[NMAX];

    int prim, ultim;

    nod* p;

    C[0]=start;

    d[start]=0;

    prim=ultim=0;

    uz[start]=1;

    while (prim<=ultim)

    {


        x=C[prim];

        prim++;

        for (p=L[x]; p!=NULL; p=p->urm)

            if (uz[p->vf]==0)

            {

                uz[p->vf]=1;

                d[p->vf]=d[x]+1;

                ultim++;

                C[ultim]=p->vf;

            }

    }

}

int lg(int y)

{

    if (d[y]==0&&y!=start)

        return -1;

    return d[y];

}



void citire()

{
    int x, y, i;

    fin>>n>>m>>start;

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

    {

        fin>>x>>y;

        inserare(L[x], y, p[x]);

        if (p[x]==NULL)

            p[x]=L[x];

        else

            p[x]=p[x]->urm;

    }

}

void inserare(LSI& L, int x, nod* p)

{

    nod* q = new nod;

    q->vf=x;

    if (p==NULL)

    {

        q->urm=L;

        L=q;

    }

    else

    {

        q->urm = p->urm;

        p->urm = q;
    }

}