using AtCoderBeginnerContest148.Questions;
using AtCoderBeginnerContest148.Extensions;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace AtCoderBeginnerContest148.Questions
{
    public class QuestionF : AtCoderQuestionBase
    {
        List<int>[] nodes;
        int[] takahashiDistances;
        int[] aokiDistances;

        public override IEnumerable<object> Solve(TextReader inputStream)
        {
            var nuv = inputStream.ReadIntArray();
            var nodeCount = nuv[0];
            var takahashiPosition = nuv[1] - 1;
            var aokiPosition = nuv[2] - 1;

            nodes = Enumerable.Range(0, nodeCount).Select(_ => new List<int>()).ToArray();
            takahashiDistances = new int[nodeCount];
            aokiDistances = new int[nodeCount];
            for (int i = 0; i < nodeCount - 1; i++)
            {
                var ab = inputStream.ReadIntArray().Select(j => j - 1).ToArray();
                var a = ab[0];
                var b = ab[1];
                nodes[a].Add(b);
                nodes[b].Add(a);
            }

            Search(aokiPosition, false);
            Search(takahashiPosition, true);

            yield return takahashiDistances.Max();
        }

        void Search(int initialNode, bool isTakahashi)
        {
            var seen = Enumerable.Range(0, nodes.Length).Select(i => i == initialNode).ToArray();
            var toDo = new Queue<int>();
            toDo.Enqueue(initialNode);

            while (toDo.Any())
            {
                var currentNode = toDo.Dequeue();

                foreach (var nextNode in nodes[currentNode].Where(n => !seen[n]))
                {
                    seen[nextNode] = true;
                    if (isTakahashi)
                    {
                        if (aokiDistances[nextNode] > takahashiDistances[currentNode] + 1)
                        {
                            takahashiDistances[nextNode] = takahashiDistances[currentNode] + 1;
                        }
                    }
                    else
                    {
                        aokiDistances[nextNode] = aokiDistances[currentNode] + 1;
                    }

                    if (!isTakahashi || aokiDistances[nextNode] > takahashiDistances[nextNode])
                    {
                        toDo.Enqueue(nextNode);
                    }
                }
            }
        }
    }
}


namespace AtCoderBeginnerContest148
{
    class Program
    {
        static void Main(string[] args)
        {
            IAtCoderQuestion question = new QuestionF();    // 問題に合わせて書き換え
            var answers = question.Solve(Console.In);
            foreach (var answer in answers)
            {
                Console.WriteLine(answer);
            }
        }
    }
}

#region Base Classes

namespace AtCoderBeginnerContest148.Questions
{

    public interface IAtCoderQuestion
    {
        IEnumerable<object> Solve(string input);
        IEnumerable<object> Solve(TextReader inputStream);
    }

    public abstract class AtCoderQuestionBase : IAtCoderQuestion
    {
        public IEnumerable<object> Solve(string input)
        {
            var stream = new MemoryStream(Encoding.Unicode.GetBytes(input));
            var reader = new StreamReader(stream, Encoding.Unicode);

            return Solve(reader);
        }

        public abstract IEnumerable<object> Solve(TextReader inputStream);
    }

}

#endregion

namespace AtCoderBeginnerContest148.Algorithms
{
    public static class BasicAlgorithm
    {
        public static long Gcd(long a, long b)
        {
            if (a <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(a), $"{nameof(b)}は正の整数である必要があります。");
            }
            if (b <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(b), $"{nameof(b)}は正の整数である必要があります。");
            }
            if (a < b)
            {
                var temp = a;
                a = b;
                b = temp;
            }

            while (b != 0)
            {
                var temp = a % b;
                a = b;
                b = temp;
            }
            return a;
        }

        public static long Lcm(long a, long b)
        {
            if (a <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(a), $"{nameof(b)}は正の整数である必要があります。");
            }
            if (b <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(b), $"{nameof(b)}は正の整数である必要があります。");
            }

            return a / Gcd(a, b) * b;
        }
    }
}
#region Extensions

    namespace AtCoderBeginnerContest148.Extensions
{
    internal static class TextReaderExtensions
    {
        internal static int ReadInt(this TextReader reader) => int.Parse(ReadString(reader));
        internal static long ReadLong(this TextReader reader) => long.Parse(ReadString(reader));
        internal static double ReadDouble(this TextReader reader) => double.Parse(ReadString(reader));
        internal static string ReadString(this TextReader reader) => reader.ReadLine();

        internal static int[] ReadIntArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(int.Parse).ToArray();
        internal static long[] ReadLongArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(long.Parse).ToArray();
        internal static double[] ReadDoubleArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(double.Parse).ToArray();
        internal static string[] ReadStringArray(this TextReader reader, char separator = ' ') => reader.ReadLine().Split(separator);
    }
}

#endregion