//ヘッダー
#include<bits/stdc++.h>
using namespace std;

//型定義
typedef long long ll;

//定数
const int INF=1e+9;
const int MOD=1e+9+7;

//REPマクロ
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define REP2(i,a,b) for(ll i=a;i<(ll)(b);i++)
#define REPD2(i,a,b) for(ll i=a;i>(ll)(b);i--)

// 多次元 vector 生成
template<class T>
vector<T> make_vec(size_t a){
    return vector<T>(a);
}
template<class T, class... Ts>
auto make_vec(size_t a, Ts... ts){
  return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}

//vectorの扱い
#define ALL(x) (x).begin(),(x).end() //sortなどの引数省略
#define SIZE(x) ((ll)(x).size()) //size
#define MAX(x) *max_element(ALL(x)) //最大値
#define MIN(x) *min_element(ALL(x)) //最小値

using Graph = vector<vector<int>>;

int main(){
    int N,u,v;
    cin>>N>>u>>v;
    u--;
    v--;
    // グラフ入力受取 (ここでは無向グラフを想定)
    Graph G(N);
    for (int i = 0; i < N-1; ++i) {
        int a, b;
        cin >> a >> b;
        a--;
        b--;
        G[a].push_back(b);
        G[b].push_back(a);
    }
    
    // BFS のためのデータ構造
    vector<int> dist_taka(N, -1);
    vector<int> dist_ao(N, -1);
    vector<int> dist(N, -1);
    queue<int> que;
    
    // taka
    dist_taka[u] = 0;
    que.push(u); // 0 を橙色頂点にする
    
    // BFS 開始 (キューが空になるまで探索を行う)
    while (!que.empty()) {
        int v_ = que.front(); // キューから先頭頂点を取り出す
        que.pop();
    
        // v から辿れる頂点をすべて調べる
        for (int nv : G[v_]) {
            if (dist_taka[nv] != -1) continue; // すでに発見済みの頂点は探索しない
    
            // 新たな白色頂点 nv について距離情報を更新してキューに追加する
            dist_taka[nv] = dist_taka[v_] + 1;
            que.push(nv);
        }
    }

    // ao
    dist_ao[v] = 0;
    que.push(v); // 0 を橙色頂点にする
    
    // BFS 開始 (キューが空になるまで探索を行う)
    while (!que.empty()) {
        int v_ = que.front(); // キューから先頭頂点を取り出す
        que.pop();
    
        // v から辿れる頂点をすべて調べる
        for (int nv : G[v_]) {
            if (dist_ao[nv] != -1) continue; // すでに発見済みの頂点は探索しない
    
            // 新たな白色頂点 nv について距離情報を更新してキューに追加する
            dist_ao[nv] = dist_ao[v_] + 1;
            que.push(nv);
        }
    }

    int dis=dist_taka[v];
    int mid=(dis-1)/2;
    int k,l;
    REP(i,N){
        if(dist_taka[i]==mid&&dist_ao[i]==dis-mid){
            k=i;
        }else if(dist_taka[i]==mid+1&&dist_ao[i]==dis-1-mid){
            l=i;
        }
    }

    REP(i,G[k].size()){
        if(G[k][i]==l){
            G[k].erase(G[k].begin()+i);
        }
    }

    REP(i,G[l].size()){
        if(G[l][i]==k){
            G[l].erase(G[l].begin()+i);
        }
    }

    dist[k] = 0;
    que.push(k); // 0 を橙色頂点にする
    
    // BFS 開始 (キューが空になるまで探索を行う)
    while (!que.empty()) {
        int v_ = que.front(); // キューから先頭頂点を取り出す
        que.pop();
    
        // v から辿れる頂点をすべて調べる
        for (int nv : G[v_]) {
            if (dist[nv] != -1) continue; // すでに発見済みの頂点は探索しない
    
            // 新たな白色頂点 nv について距離情報を更新してキューに追加する
            dist[nv] = dist[v_] + 1;
            que.push(nv);
        }
    }

    int goal=-1;
    int idx=-1;
    REP(i,N){
        if(goal<dist[i]){
            goal=dist[i];
            idx=i;
        }
    }

    cout<<dist_ao[idx]-1<<endl;

    

}

Measured memory_bytes: 10020