module Main
  ( main
  )
where

import           Control.Applicative
import           Control.Monad
import           Data.List
import qualified Data.Vector                   as V
import           Data.Char
import           Data.Bits
import qualified Data.ByteString.Char8         as BS
import           Data.Maybe

parse = fst . fromJust
parseInt = parse . BS.readInt
parseInteger = parse . BS.readInteger
readInt = parseInt <$> BS.getLine
readInteger = parseInteger <$> BS.getLine
readIntList = map parseInt . BS.words <$> BS.getLine

main = do
  [n, u, v] <- readIntList
  arr       <- concat
    <$> replicateM (n - 1) ((\[a, b] -> [(a - 1, b - 1), (b - 1, a - 1)]) <$> readIntList)
  let
    graph    = createUnweightedGraphFromList arr
    dist1    = depthFirstSearchTree (u - 1) graph
    dist2    = depthFirstSearchTree (v - 1) graph
    farthest = maximum . map snd . filter (\(a, b) -> a < b) $ zip dist1 dist2
  print $ farthest - 1

type Vertex = Int
type Cost = Int
type Capacity = Int

data Edge = Edge { from :: Vertex, to :: Vertex, cost :: Cost, cap :: Capacity } deriving (Eq, Ord, Show)
createUnweightedEdge (from, to) =
  Edge { from = from, to = to, cost = 1, cap = 0 }
createUnweightedEdgeVectorFromList :: [(Vertex, Vertex)] -> V.Vector Edge
createUnweightedEdgeVectorFromList = V.fromList . map createUnweightedEdge

type Graph = V.Vector (V.Vector Edge)
createUnweightedGraphFromList :: [(Vertex, Vertex)] -> Graph
createUnweightedGraphFromList =
  V.fromList
    . map createUnweightedEdgeVectorFromList
    . groupBy (\a b -> fst a == fst b)
    . sort

depthFirstSearchTree :: Vertex -> Graph -> [Cost]
depthFirstSearchTree src =
  map snd . sort . depthFirstSearchTreeUpdate (src, src, 0)

depthFirstSearchTreeUpdate
  :: (Vertex, Vertex, Cost) -> Graph -> [(Vertex, Cost)]
depthFirstSearchTreeUpdate (v, p, c) graph =
  let
    newVisited =
      concatMap
          (\e -> depthFirstSearchTreeUpdate (to e, from e, c + cost e) graph)
        . V.filter (\e -> to e /= p)
        $ graph V.! v
  in  newVisited ++ [(v, c)]
