// #define DEBUGGING
#include <bits/stdc++.h>
#define endl '\n'
#define ALL(V) (V).begin(), (V).end()
#define ALLR(V) (V).rbegin(), (V).rend()
template <typename T> using V = std::vector<T>;
template <typename T> using VV = V<V<T>>;
using ll = std::int64_t;
using ull = std::uint64_t;
using PLL = std::pair<ll, ll>;
using TLL = std::tuple<ll, ll, ll>;
template <typename T> const T& var_min(const T &t) { return t; }
template <typename T> const T& var_max(const T &t) { return t; }
template <typename T, typename... Tail> const T& var_min(const T &t, const Tail&... tail) { return std::min(t, var_min(tail...)); }
template <typename T, typename... Tail> const T& var_max(const T &t, const Tail&... tail) { return std::max(t, var_max(tail...)); }
template <typename T, typename... Tail> void chmin(T &t, const Tail&... tail) { t = var_min(t, tail...); }
template <typename T, typename... Tail> void chmax(T &t, const Tail&... tail) { t = var_max(t, tail...); }
template <typename T> const T& clamp(const T &t, const T &low, const T &high) { return std::max(low, std::min(high, t)); }
template <typename T> void chclamp(T &t, const T &low, const T &high) { return t = clamp(t, low, high); }
namespace init__ { struct InitIO { InitIO() { std::cin.tie(nullptr); std::ios_base::sync_with_stdio(false); std::cout << std::fixed << std::setprecision(30); } } init_io; }
#define mv_rec make_v(init, tail...)
template <typename T> T make_v(T init) { return init; }
template <typename T, typename... Tail> auto make_v(T init, size_t s, Tail... tail) { return V<decltype(mv_rec)>(s, mv_rec); }
#undef mv_rec
using namespace std;
#ifdef DEBUGGING
#include "../../debug/debug.cpp"
#else
#define DEBUG(...) 0
#define DEBUG_SEPARATOR_LINE 0
#endif

VV<ll> edges;
ll N;

const ll inf = 5e15;

void dfs(ll cur, ll pre, V<ll> &dists, ll d) {
    dists[cur] = d;
    for(ll nxt : edges[cur]) if(nxt != pre) dfs(nxt, cur, dists, d + 1);;
}

int main() {
    ll N, u, v;
    cin >> N >> u >> v;
    u--; v--;
    edges.resize(N);
    for(ll i = 1; i < N; i++) {
        ll a, b;
        cin >> a >> b;
        a--; b--;
        edges[a].push_back(b);
        edges[b].push_back(a);
    }

    V<ll> fu(N), fv(N);
    dfs(u, -1, fu, 0);
    dfs(v, -1, fv, 0);

    ll ans = 0;
    for(ll i = 0; i < N; i++) {
        if(fv[i] < fu[i]) continue;
        if(fv[i] == fu[i]) {
            bool ok = true;
            for(ll nxt : edges[i]) {
                if(fv[nxt] == fu[nxt] && fv[nxt] + 1 == fv[i]) {
                    ok = false;
                    break;
                }
            }
            if(!ok) continue;
        }
        ll tmp = fu[i];
        ll diff = fu[i] - fv[i];
        tmp += diff / 2 * 2;
        DEBUG(make_tuple(i, tmp, fu[i], fv[i]));
        chmax(ans, tmp);
    }

    cout << ans << endl;
    return 0;
}
