import java.util.Scanner
import Math.max

object Main extends App {
  val sc = new Scanner(System.in)

  val fene = "Fennec"
  val snuke = "Snuke"

  val N = sc.nextInt()
  val edges = Array.fill[List[Int]](N+1)(Nil)
  for (_ <- 1 to N-1) {
    val a, b = sc.nextInt()
    edges(a) = b :: edges(a)
    edges(b) = a :: edges(b)
  }


  // fenec
  val stack = new scala.collection.mutable.Stack[(Int, Int)]
  val dp = new Array[Boolean](N+1)
  dp(1) = true

  var feneMax = 0
  
  for(e <- edges(1)) {
    stack.push((e, 1))
    dp(e) = true
  }

  while(!stack.isEmpty) {
    val (node, score) = stack.pop

    node match {
      case N =>
        if((score-1) % 2 == 1) feneMax = max(feneMax, score-1)
      case _ =>
        feneMax = max(feneMax, score)
        var flag = true
        for(e <- edges(node)) {
          if(!dp(e)) {
            flag = false
            stack.push((e, score+1))
            dp(e) = true
          }
        }
        if(flag) feneMax = max(feneMax, score)
    }
  }


  // snuke
  for(i <- 1 to N)
    dp(i) = false
  dp(N) = true

  var snukeMax = 0
  
  for(e <- edges(N)) {
    stack.push((e, 1))
    dp(e) = true
  }

  while(!stack.isEmpty) {
    val (node, score) = stack.pop

    node match {
      case 1 =>
        if((score-1) % 2 == 1) snukeMax = max(snukeMax, score-1)
      case _ =>
        snukeMax = max(snukeMax, score)
        var flag = true
        for(e <- edges(node)) {
          if(!dp(e)) {
            flag = false
            stack.push((e, score+1))
            dp(e) = true
          }
        }
        if(flag) snukeMax = max(snukeMax, score)
    }
  }

  if(feneMax > snukeMax)
    println(fene)
  else
    println(snuke)
}
