#include <vector>
#include <cstdio>
#include <queue>

class Graph
{
public:
        Graph(std::size_t nr_noduri, std::vector<std::vector<int>>&& l_adiacenta)
            : nr_noduri(nr_noduri)
            , l_adiacenta(std::move(l_adiacenta))
        {
        }

        int componente_conexe() const
        {
                std::vector<bool> visited(nr_noduri + 1, false);

                int res = 0;
                for(int node = 1; node <= (int)nr_noduri; ++node)
                {
                        if(!visited[node])
                        {
                                ++res;
                                DFS(visited, node);
                        }
                }

                return res;
        }

        std::vector<int> distante_minime(const int start) const
        {
                std::vector<int> distante(nr_noduri + 1, -1);

                BFS(distante, start);

                return distante;
        }

private:
        void DFS(std::vector<bool>& visited, int start) const
        {
                visited[start] = true;

                for(int v : l_adiacenta[start])
                {
                        if(!visited[v])
                        {
                                DFS(visited, v);
                        }
                }
        }

        void BFS(std::vector<int>& dists, int start) const
        {
                std::queue<int> q;
                q.push(start);
                dists[start] = 0;

                while(!q.empty())
                {
                        const auto node = q.front();
                        q.pop();

                        for(int v : l_adiacenta[node])
                        {
                                if(dists[v] == -1)
                                {
                                        q.push(v);
                                        dists[v] = dists[node] + 1;
                                }
                        }
                }
        }

private:
        std::size_t nr_noduri;
        std::vector<std::vector<int>> l_adiacenta;
};

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

        int n, m, s;
        std::scanf("%d %d %d", &n, &m, &s);

        const Graph g = [&]()
        {
                std::vector<std::vector<int>> list(n + 1);
                for(int i = 0; i < m; ++i)
                {
                        int x, y;
                        std::scanf("%d %d", &x, &y);

                        list[x].push_back(y);
                }

                return Graph(n, std::move(list));
        }();

        const auto dists = g.distante_minime(s);
        for(std::size_t i = 1; i < dists.size(); ++i)
        {
                std::printf("%d ", dists[i]);
        }

        puts("");
}