/// @author Camillus <3
#include "bits/stdc++.h"
using namespace std;

static constexpr int max_n = 2'000'000;

vector<int> g[max_n];
int parent[max_n];

int root;

int dp[max_n];

void dfs(int u, int p, int sum) {
    parent[u] = p;

    auto it = find(g[u].begin(), g[u].end(), p);
    if (it != g[u].end()) g[u].erase(it);

    for (int v : g[u]) {
        dfs(v, u, sum + g[v].size() - 2);
    }

    if (g[u].empty()) {
        dp[u] = sum;
    } else {
        if (g[u].size() == 1) {
            dp[u] = sum;
        } else {
            sort(g[u].begin(), g[u].end(), [&](int u, int v) -> bool {
                return dp[u] > dp[v];
            });
            dp[u] = dp[g[u][1]] + 1;
        }
    }
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m;
    cin >> n >> root >> m;

    for (int i = 0; i < n - 1; i++) {
        int u, v;
        cin >> u >> v;

        g[u].push_back(v);
        g[v].push_back(u);
    }

    dfs(root, -1, 1);

    int l = -1, r = 2 * n;

    while (r - l > 1) {
        int x = (l + r) / 2;
        int bank = 1;
        int used = 0;

        int u = m;

        int last = -1;

        while (u != root) {

            int last_used = used;

            for (int v : g[u]) {
                if (v == last) {
                    continue;
                }

                if (dp[v] + last_used + 1 - (last != -1) > x) {
                    bank -= 1;
                    used += 1;
                }
            }

            if (bank < 0) {
                break;
            }

            last = u;
            u = parent[u];
            bank += 1;
        }

        if (bank < 0 || used > x) {
            l = x;
        } else {
            r = x;
        }
    }

    cout << r << '\n';
    return 0;
}