package main

import (
    "bufio"
    "os"
    "fmt"
    "strconv"
    "container/heap"
)

const INF = 1000000000000000

/*********** PriorityQueue ***********/
type PriorityQueue struct {
    arr []interface{}
    comps []CompFunc
}
/*
p < q ... -1
p == q ... 0
p > q ...  1
*/
type CompFunc func(p, q interface{}) int

func NewPriorityQueue() *PriorityQueue {
    return new(PriorityQueue)
}

func (pq PriorityQueue) Len() int {
    return len(pq.arr)
}

func (pq PriorityQueue) Swap(i, j int) {
    pq.arr[i], pq.arr[j] = pq.arr[j], pq.arr[i]
}

func (pq PriorityQueue) Less(i, j int) bool{
    for _, comp := range pq.comps {
        result := comp(pq.arr[i], pq.arr[j])
        switch result {
            case -1: return true
            case 1:  return false
            case 0:  continue
        }
    }
    return true
}

func (pq *PriorityQueue) Push(x interface{}) {
    pq.arr = append(pq.arr, x)
}

func (pq *PriorityQueue) Pop() interface{} {
    n := pq.Len()
    item := pq.arr[n - 1]
    pq.arr = pq.arr[:n - 1]
    return item
}

func (pq *PriorityQueue) IsEmpty() bool {
    return pq.Len() == 0
}



/* for dijkstra */
/* type Edge */
type Edge struct {
    to int
    cost int
}

/* type State */
type State struct {
    score int
    node int
}

/* type Graph */
type Graph struct {
    starts []State
    edges [][]Edge
    size int
    comps []CompFunc
    defaultScore int
}

func dijkstra(graph *Graph) []int {
    score := make([]int, graph.size)
    for i := 0; i < graph.size; i++ {
        score[i] = graph.defaultScore
    }
    que := new(PriorityQueue)
    que.comps = graph.comps
    for _, start := range graph.starts {
        score[start.node] = start.score
        heap.Push(que, start)
    }
    for !que.IsEmpty() {
        state := heap.Pop(que).(State)
        for _, edge := range graph.edges[state.node] {
            newScore := state.score + edge.cost
            if score[edge.to] > newScore {
                score[edge.to] = newScore
                heap.Push(que, State{score: newScore, node: edge.to})
            }
        }
    }
    return score
}

/* input */
var sc = bufio.NewScanner(os.Stdin)

func readInt() int {
    sc.Scan()
    n, _ := strconv.Atoi(sc.Text())
    return n
}

func main() {
    sc.Split(bufio.ScanWords)
    n := readInt()
    var edges [][]Edge
    for i := 0; i < n; i++ {
        edges = append(edges, make([]Edge, 0))
    }
    for i := 0; i < n - 1; i++ {
        a, b := readInt() - 1, readInt() - 1
        edges[a] = append(edges[a], Edge{to:b, cost:1})
        edges[b] = append(edges[b], Edge{to:a, cost:1})
    }
    comp := func(p, q interface{}) int {
        if p.(State).score < q.(State).score {
            return -1
        } else if p.(State).score == q.(State).score {
            return 0
        } else {
            return 1
        }
        return 0
    }
    comps := make([]CompFunc, 0)
    comps = append(comps, comp)
    starts1 := make([]State, 0)
    starts2 := make([]State, 0)
    starts1 = append(starts1, State{score:0, node:0})
    starts2 = append(starts2, State{score:0, node:n - 1})

    graph1 := new(Graph)
    graph1.edges = edges
    graph1.starts = starts1
    graph1.size = n
    graph1.comps = comps
    graph1.defaultScore = INF

    graph2 := new(Graph)
    graph2.edges = edges
    graph2.starts = starts2
    graph2.size = n
    graph2.comps = comps
    graph2.defaultScore = INF

    dist1 := dijkstra(graph1)
    dist2 := dijkstra(graph2)
    black := 0
    for i := 0; i < n; i++ {
        if dist1[i] <= dist2[i] {
            black++
        }
    }
    white := n - black
    if white >= black {
        fmt.Println("Snuke")
    } else {
        fmt.Println("Fennec")
    }
}

Measured memory_bytes: 13952