#include <bits/stdc++.h>

using namespace std;

char outBuffer[800000]; int q = -1;

__attribute__((always_inline)) void put_int(int x)
{
    if(x == -1)
    {
        outBuffer[++q] = 45;

        outBuffer[++q] = 49;

        outBuffer[++q] = 32;

        return;
    }

    int digits = x > 999999999 ? 11 :
                 x > 99999999  ? 10 :
                 x > 9999999   ? 9  :
                 x > 999999    ? 8  :
                 x > 99999     ? 7  :
                 x > 9999      ? 6  :
                 x > 999       ? 5  :
                 x > 99        ? 4  :
                 x > 9         ? 3  : 2;

    for(int i = digits; --i; x /= 10)
    {
        outBuffer[q + i] = x % 10 + 48;
    }

    outBuffer[q = q + digits] = 32;
}

#define IN_BUFFER_SIZE 1 << 16

char inBuffer[IN_BUFFER_SIZE];

int p = IN_BUFFER_SIZE;

__attribute__((always_inline)) char get_char()
{
    if(p == IN_BUFFER_SIZE)
    {
        fread(inBuffer, 1, IN_BUFFER_SIZE, stdin);

        p = 0;
    }

    return inBuffer[p++];
}

__attribute__((always_inline)) int get_int()
{
    char c = get_char(); int number = 0;

    for(; c < 48 || c > 57; c = get_char());

    for(; c > 47 && c < 58; c = get_char())

        number = number * 10 + c - 48;

    return number;
}

int vertices, edges, u, v, start, level[100001];

vector<int> adj[100001];

void BFS(int start)
{
    queue<int> q;

    q.push(start);

    level[start] = 1;

    while(!q.empty())
    {
        int current = q.front(); q.pop();

        for(int child : adj[current])
        {
            if(level[child] == 0)
            {
                q.push(child);

                level[child] = level[current] + 1;
            }
        }
    }
}

int main()
{
    freopen("bfs.in", "r", stdin);
    freopen("bfs.out", "w", stdout);

    vertices = get_int();

    edges = get_int();

    start = get_int();

    for(int i = 1; i <= edges; i++)
    {
        u = get_int();

        v = get_int();

        adj[u].push_back(v);
    }

    BFS(start);

    for(int i = 1; i <= vertices; i++)
    {
        put_int(level[i] - 1);
    }

    fwrite(outBuffer, 1, q, stdout);

    return 0;
}