using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using SB = System.Text.StringBuilder;
//using System.Threading.Tasks;
//using System.Text.RegularExpressions;
//using System.Globalization;
//using System.Diagnostics;
using static System.Console;
using System.Numerics;
using static System.Math;
using pair = Pair<int, int>;

class Program
{
    static void Main()
    {
        //SetOut(new StreamWriter(OpenStandardOutput()) { AutoFlush = false });
        new Program().solve();
        Out.Flush();
    }
    readonly Scanner cin = new Scanner();
    readonly int[] dd = { 0, 1, 0, -1, 0 }; //→↓←↑
    readonly int mod = 1000000007;
    readonly int dom = 998244353;
    bool chmax<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) < 0) { a = b; return true; } return false; }
    bool chmin<T>(ref T a, T b) where T : IComparable<T> { if (b.CompareTo(a) < 0) { a = b; return true; } return false; }

    void solve()
    {
        int N = cin.nextint;
        int U = cin.nextint - 1;
        int V = cin.nextint - 1;

        var T = new Tree();
        var HL = new HLTree(N);
        var G = T.Input(N, HL);
        HL.Build();
        int ans = 0;
        while (true)
        {
            int max = 0;
            int next = -1;
            foreach (var u in G[U])
            {
                if (chmax(ref max, HL.GetDistance(u, V)))
                {
                    next = u;
                }
            }

            if (max == 0) break;
            U = next;

            int min = int.MaxValue;
            next = -1;
            foreach (var v in G[V])
            {
                if (chmin(ref min, HL.GetDistance(v, U)))
                {
                    next = v;
                }
            }
            ans++;
            if (min == 0) break;
            V = next;

        }
        WriteLine(ans);

    }

}

/// <OriginalAuthor>camypaper</OriginalAuthor>
class HLTree
{
    readonly int n;
    readonly List<int>[] G;
    readonly int[] subtreeSize;
    readonly int[] maxsize;
    readonly int[] par;
    readonly int[] depth;
    readonly Chain[] go;
    readonly int[] pos;
    List<Chain> chains;
    public HLTree(int N)
    {
        n = N;
        G = new List<int>[n];
        chains = new List<Chain>();
        for (int i = 0; i < n; i++)
            G[i] = new List<int>();
        subtreeSize = new int[n];
        maxsize = new int[n];
        par = new int[n];
        depth = new int[n];
        go = new Chain[n];
        pos = new int[n];
    }
    public void AddEdge(int u, int v)
    {
        G[u].Add(v); G[v].Add(u);
    }
    public void Build(int root = 0)
    {
        computeSubtreeSize(root);
        Decomposite(-1, root, 0);
    }
    void computeSubtreeSize(int r)
    {
        var stack = new Stack<int>();
        stack.Push(r);
        var iter = new int[n];
        par[r] = -1;
        //dfs
        while (stack.Count > 0)
        {
            var cur = stack.Peek();
            if (iter[cur] == G[cur].Count)
            {
                stack.Pop();
                subtreeSize[cur]++;
                if (par[cur] != -1)
                {
                    subtreeSize[par[cur]] += subtreeSize[cur];
                    maxsize[par[cur]] = Math.Max(maxsize[par[cur]], subtreeSize[cur]);
                }
                continue;
            }
            var next = G[cur][iter[cur]++];
            if (next == par[cur]) continue;
            par[next] = cur;
            depth[next] = depth[cur] + 1;
            stack.Push(next);
        }
    }
    void Decomposite(int from, int cur, int lv)
    {
        var chain = new Chain(from, lv);
        chains.Add(chain);
        chain.Add(cur);
        while (cur != from)
        {
            var next = cur;
            go[cur] = chain;
            pos[cur] = chain.Count;
            foreach (var to in G[cur])
            {
                if (to == from) continue;
                if (maxsize[cur] == subtreeSize[to])
                {
                    maxsize[cur] = -1;
                    next = to;
                    chain.Add(to);
                }
                else Decomposite(cur, to, lv + 1);
            }

            from = cur;
            cur = next;

        }
        chain.Init();
    }
    public int GetDistance(int a, int b)
    {
        return depth[a] + depth[b] - 2 * depth[GetLCA(a, b)];
    }
    public int GetLCA(int u, int v)
    {
        while (go[u] != go[v])
        {
            if (go[u].Level < go[v].Level) v = go[v].From;
            else u = go[u].From;
        }
        if (depth[u] <= depth[v]) return u;
        else return v;
    }
    public int this[int u]
    {
        get { return depth[u]; }
    }
}

class Chain
{
    public int From { get; set; }
    public int Level { get; set; }
    public int Count { get; private set; }
    List<int> heavy;
    public Chain(int from, int lv)
    {
        From = from;
        Level = lv;
        heavy = new List<int>();
    }
    public void Add(int v)
    {
        //heavy.Add(v);
        Count++;
    }
    public void Init()
    {

    }
}

class Tree
{
    public List<int>[] Input(int n, HLTree H, int indexed = 1)
    {
        Scanner cin = new Scanner();
        var ret = new List<int>[n];
        for (int i = 0; i < ret.Length; i++) ret[i] = new List<int>();
        for (int i = 0; i < n - 1; i++)
        {
            int a = cin.nextint - indexed;
            int b = cin.nextint - indexed;
            ret[a].Add(b);
            ret[b].Add(a);
            H.AddEdge(a, b);
        }
        return ret;
    }
    public int BFS(List<int>[] T, int s, out int[] dist, int ban, IEnumerable<int> multi = null)
    {
        int n = T.Length;
        dist = new int[n];
        for (int i = 0; i < dist.Length; i++) dist[i] = -1;

        var Q = new Queue<int>();
        if (multi == null) { Q.Enqueue(s); dist[s] = 0; }
        else foreach (var v in multi) { Q.Enqueue(v); dist[v] = 0; }
        int id = s;

        while (Q.Count > 0)
        {
            var u = Q.Dequeue();
            if (u == ban) continue;
            foreach (var v in T[u])
            {
                if (dist[v] >= 0) continue;
                dist[v] = dist[u] + 1;
                id = v;
                Q.Enqueue(v);
            }
        }
        return id;
    }
    //public int Diameter(List<int>[] T)
    //{
    //    int[] dist;
    //    var far = BFS(T, BFS(T, 0, out dist), out dist);
    //    return dist[far];
    //}
}

static class Ex
{
    public static void join<T>(this IEnumerable<T> values, string sep = " ") => WriteLine(string.Join(sep, values));
    public static string concat<T>(this IEnumerable<T> values) => string.Concat(values);
    public static string reverse(this string s) { var t = s.ToCharArray(); Array.Reverse(t); return t.concat(); }

    public static int lower_bound<T>(this IList<T> arr, T val) where T : IComparable<T>
    {
        int low = 0, high = arr.Count;
        int mid;
        while (low < high)
        {
            mid = ((high - low) >> 1) + low;
            if (arr[mid].CompareTo(val) < 0) low = mid + 1;
            else high = mid;
        }
        return low;
    }
    public static int upper_bound<T>(this IList<T> arr, T val) where T : IComparable<T>
    {
        int low = 0, high = arr.Count;
        int mid;
        while (low < high)
        {
            mid = ((high - low) >> 1) + low;
            if (arr[mid].CompareTo(val) <= 0) low = mid + 1;
            else high = mid;
        }
        return low;
    }
}

class Pair<T, U> : IComparable<Pair<T, U>> where T : IComparable<T> where U : IComparable<U>
{
    public T f; public U s;
    public Pair(T f, U s) { this.f = f; this.s = s; }
    public int CompareTo(Pair<T, U> a) => f.CompareTo(a.f) != 0 ? f.CompareTo(a.f) : s.CompareTo(a.s);
    public override string ToString() => $"{f} {s}";
}

class Scanner
{
    string[] s; int i;
    readonly char[] cs = new char[] { ' ' };
    public Scanner() { s = new string[0]; i = 0; }
    public string[] scan => ReadLine().Split();
    public int[] scanint => Array.ConvertAll(scan, int.Parse);
    public long[] scanlong => Array.ConvertAll(scan, long.Parse);
    public double[] scandouble => Array.ConvertAll(scan, double.Parse);
    public string next
    {
        get
        {
            if (i < s.Length) return s[i++];
            string st = ReadLine();
            while (st == "") st = ReadLine();
            s = st.Split(cs, StringSplitOptions.RemoveEmptyEntries);
            i = 0;
            return next;
        }
    }
    public int nextint => int.Parse(next);
    public long nextlong => long.Parse(next);
    public double nextdouble => double.Parse(next);
}
