{-# LANGUAGE BangPatterns, MultiWayIf #-}
import Control.Arrow
import Control.Monad.Fix
import Data.Int
import Data.Graph
import Data.Foldable
import Data.List
import qualified Data.Vector as V
import qualified Data.Vector.Unboxed as VU
import qualified Data.ByteString.Char8 as B
import Data.ByteString.Internal (accursedUnutterablePerformIO)
import Debug.Trace

solve :: Int -> VU.Vector (Int, Int) -> String
solve !n !abn =
  if length (reachable graph' 0) > length (reachable graph' (n - 1))
    then "Fennec"
    else "Snuke"
 where
  graphFrom :: VU.Vector (Int, Int) -> V.Vector [Int]
  graphFrom vec =
    V.accum (flip (:)) (V.replicate n []) $ VU.toList vec ++ VU.toList
      (VU.map (\(!x, !y) -> (y, x)) vec)

  graph :: V.Vector [Int]
  graph = graphFrom abn

  graph' :: Graph
  graph' =
    let (!x, !y) = findHalf $ findPathBetween 0 (n - 1)
    in  buildG (0, (n - 1)) $ VU.toList $ VU.filter
          (\(!a, !b) -> (a, b) /= (x, y) && (b, a) /= (x, y))
          abn

  countFrom :: Int -> V.Vector [Int] -> Int
  countFrom s gr = go s 0 [s]
   where
    go !s !acc !path =
      let next = gr V.! s
      in
        foldl'
          (\(!acc) (!n) -> if n `notElem` path then go n acc (s : path) else acc
          )
          (acc + 1)
          next

  findHalf :: [Int] -> (Int, Int)
  findHalf xs =
    let n = length xs
    in  if even n
          then (xs !! (n `div` 2 - 1), xs !! (n `div` 2))
          else (xs !! (n `div` 2), xs !! (n `div` 2 + 1))

  findPathBetween :: Int -> Int -> [Int]
  findPathBetween s t = reverse $ (t :) $ go s t []
   where
    go s t acc
      | s == t
      = acc
      | otherwise
      = let next = graph V.! s
        in  (\xs -> if null xs then [] else head xs) $ filter
              (not . null)
              [ go n t (s : acc) | n <- next, n `notElem` acc ]

main = do
  let readInt :: Integral a => B.ByteString -> Maybe (a, B.ByteString)
      readInt = fmap (first fromIntegral . second B.tail) . B.readInt

  n   <- (\vec -> (vec VU.! 0)) . VU.unfoldrN 1 readInt <$> B.getLine
  abn <-
    VU.replicateM (n - 1)
    $   (\vec -> (vec VU.! 0 - 1, vec VU.! 1 - 1))
    .   VU.unfoldrN 2 readInt
    <$> B.getLine

  putStrLn $ solve n abn
