Problem:
Score : 400 points

Problem Statement

Fennec and Snuke are playing a board game.

On the board, there are N cells numbered 1 through N, and N-1 roads, each connecting two cells. Cell a_i is adjacent to Cell b_i through the i-th road. Every cell can be reached from every other cell by repeatedly traveling to an adjacent cell. In terms of graph theory, the graph formed by the cells and the roads is a tree.

Initially, Cell 1 is painted black, and Cell N is painted white. The other cells are not yet colored.
Fennec (who goes first) and Snuke (who goes second) alternately paint an uncolored cell.
More specifically, each player performs the following action in her/his turn:

Fennec: selects an uncolored cell that is adjacent to a black cell, and paints it black.

Snuke: selects an uncolored cell that is adjacent to a white cell, and paints it white.

A player loses when she/he cannot paint a cell. Determine the winner of the game when Fennec and Snuke play optimally.

Constraints

2 \leq N \leq 10^5

1 \leq a_i, b_i \leq N

The given graph is a tree.

Input

Input is given from Standard Input in the following format:

N
a_1 b_1
:
a_{N-1} b_{N-1}

Output

If Fennec wins, print Fennec; if Snuke wins, print Snuke.

Sample Input 1

7
3 6
1 2
3 1
7 4
5 7
1 4

Sample Output 1

Fennec

For example, if Fennec first paints Cell 2 black, she will win regardless of Snuke's moves.

Sample Input 2

4
1 4
4 2
2 3

Sample Output 2

Snuke

Solution in Haskell (GHC 7.10.3) (judge verdict: Wrong Answer)

import qualified Data.ByteString.Char8 as BC
import qualified Data.IntMap as M
import Data.Maybe (fromJust)
import Data.List
import Data.Array.IO
import Control.Monad

type Weight = Int
type Vertex = (Int, Weight)
type Graph = M.IntMap Neighbor
type Neighbor = M.IntMap Weight

main = do
  n <- readLn :: IO Int
  edge <- (\[x, y] -> zip x y) . transpose <$> getInt2DListBC
  fennec <- newArray (1, n) 0 :: IO (IOUArray Int Int)
  snuke <- newArray (1, n) 0 :: IO (IOUArray Int Int)
  fMark <- newArray (1, n) False :: IO (IOUArray Int Bool)
  sMark <- newArray (1, n) False :: IO (IOUArray Int Bool)
  let graph = foldl makeGraph M.empty edge
      fNeighbors = M.toList . fromJust $ M.lookup 1 graph
      sNeighbors = M.toList . fromJust $ M.lookup n graph
  writeArray fMark 1 True
  writeArray sMark n True
  foldM (search graph fennec 1) fMark fNeighbors
  foldM (search graph snuke n) sMark sNeighbors
  [x, y] <- group . sort <$> mapM (game fennec snuke) [1..n]
  if length x > length y then putStrLn "Fennec"
                         else putStrLn "Snuke"

bsToInt :: BC.ByteString -> Int
bsToInt = fst . fromJust . BC.readInt

getInt2DListBC :: IO [[Int]]
getInt2DListBC = map (map bsToInt . BC.words) . BC.lines <$> BC.getContents

game :: IOUArray Int Int -> IOUArray Int Int -> Int -> IO Int
game fennec snuke i = do
  f <- readArray fennec i
  s <- readArray snuke i
  return $ if f < s then 0 else 1
makeGraph :: Graph -> (Int, Int) -> Graph
makeGraph graph (x, y) = let nX = M.lookup x graph
                             nY = M.lookup y graph
                             vX = if nX == Nothing
                                    then M.insert x (addNeighbor (y, 1) M.empty) graph
                                    else M.insert x (addNeighbor (y, 1) $ fromJust nX) graph
                         in if nY == Nothing
                              then M.insert y (addNeighbor (x, 1) M.empty) vX
                              else M.insert y (addNeighbor (x, 1) $ fromJust nY) vX

readWeight :: IOUArray Int Int -> Int -> (Int, Int) -> IO Int
readWeight weight k (x, y) = do
  kx <- readArray weight x
  ky <- readArray weight y
  return $ kx + ky

addNeighbor :: (Int, Int) -> Neighbor -> Neighbor
addNeighbor (i, weight) ne = M.insert i weight ne

readEdge :: Graph -> (Int, Int) -> Int
readEdge graph (i, j) = let ne = fromJust $ M.lookup i graph
                        in fromJust $ M.lookup j ne

search :: Graph -> IOUArray Int Int -> Int -> IOUArray Int Bool -> Vertex -> IO (IOUArray Int Bool)
search graph weight pre mark (i, w) = do
  isMark <- readArray mark i
  case isMark of
    True -> do
      return mark
    False -> do
      writeArray mark i True
      let ne = M.toList . fromJust $ M.lookup i graph
      wSum <- readArray weight pre
      writeArray weight i (wSum + w)
      return =<< foldM (search graph weight i) mark ne