import qualified Data.ByteString.Char8 as B
import qualified Data.IntSet as S
import Data.Maybe
import Data.Array.IArray

data Player = Fennec | Snuke deriving (Eq,Show)

type Vertex = Int
type Vertexes = S.IntSet
type Edge = (Vertex,Vertex)
type Graph = Array Vertex [Vertex]

buildG :: Int -> [Edge] -> Graph
buildG n es = accumArray (flip (:)) [] (1,n) es

main :: IO ()
main = do
 n <- readLn
 es <- concatMap readEdge . B.lines <$> B.getContents
 let g = buildG n es
 print (versus n g)

readEdge :: B.ByteString -> [Edge]
readEdge = (\[a,b] -> [(a,b),(b,a)]) . map (fst . fromJust . B.readInt) . B.words

versus :: Vertex -> Graph -> Player
versus n g = if nf > div n 2 then Fennec else Snuke
 where nf = bfs g Fennec (S.singleton 1, S.singleton 1) (S.singleton n, S.singleton n)

transMap :: Graph -> Vertexes -> Vertexes
transMap g = S.fromList . concatMap (g!) . S.toList

bfs :: Graph -> Player -> (Vertexes,Vertexes) -> (Vertexes,Vertexes) -> Int
bfs g Fennec (sf,sfb) (ss,ssb)
 | S.null sfb = S.size sf
 | otherwise = bfs g Snuke (S.union sf sfb2, sfb2) (ss,ssb)
 where sfb2 = S.difference (transMap g sfb) (S.union sf ss)
bfs g Snuke (sf,sfb) (ss,ssb)
 | S.null ssb = bfs g Fennec (sf,sfb) (ss,ssb)
 | otherwise = bfs g Fennec (sf,sfb) (S.union ss ssb2, ssb2)
 where ssb2 = S.difference (transMap g ssb) (S.union sf ss)