#高速化heapqダイクストラ

from collections import *

from heapq import*

import sys

input=lambda:sys.stdin.readline()





def BFS(point,d):

    cost=[1e7]*(n+1)

    cost[point]=0

    Q=[]

    heappush(Q,(0,point))

    

    while Q:

        c,p=heappop(Q)

        for np in d[p]:

            if cost[np]==1e7:

                cost[np]=c+1

                heappush(Q,(c+1,np))

    return cost



n=int(eval(input()))

d={}

for i in range(n-1):

    a,b=list(map(int,input().split()))

    if a in d:

        d[a].append(b)

    else:

        d[a]=[b]

    if b in d:

        d[b].append(a)

    else:

        d[b]=[a]

        

x=BFS(1,d)[1:]

y=BFS(n,d)[1:]



#print(x,y)



F=0

S=0



for s,t in zip(x,y):

    if s<=t:

        F+=1

    else:

        S+=1



if F<=S:

    print("Snuke")

else:

    print("Fennec")

#

# 　　  ⋀_⋀　 

#　　  (･ω･)  

# .／ Ｕ ∽ Ｕ＼

#  │＊　合　＊│

#  │＊　格　＊│ 

#  │＊　祈　＊│ 

#  │＊　願　＊│ 

#  │＊　　　＊│ 

#      ￣

#

import sys

sys.setrecursionlimit(10**6)

input=sys.stdin.readline

from math import floor,sqrt,factorial,hypot,log #log2ないｙｐ

from heapq import heappop, heappush, heappushpop

from collections import Counter,defaultdict,deque

from itertools import accumulate,permutations,combinations,product,combinations_with_replacement

from bisect import bisect_left,bisect_right

from copy import deepcopy

from fractions import gcd

from random import randint

def ceil(a,b): return (a+b-1)//b

inf=float('inf')

mod = 10**9+7

def pprint(*A): 

    for a in A:     print(*a,sep='\n')

def INT_(n): return int(n)-1

def MI(): return map(int,input().split())

def MF(): return map(float, input().split())

def MI_(): return map(INT_,input().split())

def LI(): return list(MI())

def LI_(): return [int(x) - 1 for x in input().split()]

def LF(): return list(MF())

def LIN(n:int): return [I() for _ in range(n)]

def LLIN(n: int): return [LI() for _ in range(n)]

def LLIN_(n: int): return [LI_() for _ in range(n)]

def LLI(): return [list(map(int, l.split() )) for l in input()]

def I(): return int(input())

def F(): return float(input())

def ST(): return input().replace('\n', '')

def main():

    N = I()

    edge = [[] for _ in range(N)]

    for _ in range(N-1):

        a,b = MI_()

        edge[a].append(b)

        edge[b].append(a)



    def bfs(start):

        q = [start]

        d = [inf]*N

        d[start] = 0

        for i in range(N):

            tmp = []

            while q:

                v = q.pop()

                for to in edge[v]:

                    if d[to]==inf:

                        tmp.append(to)

                        d[to] = i+1

            q = tmp

        return d        

    

    fennec = bfs(0)

    snuke = bfs(N-1)



    f,s = 0,0

    for i in range(N):

        if fennec[i]<=snuke[i]:

            f+=1

        else:

            s+=1

    if f>s:

        print("Fennec")

    else:

        print("Snuke")



    



if __name__ == '__main__':

    main()

# 高速化heapqダイクストラ
from collections import *
from heapq import *
import sys

input = lambda: sys.stdin.readline()


def BFS(point, d):
    cost = [1e7] * (n + 1)
    cost[point] = 0
    Q = []
    heappush(Q, (0, point))
    while Q:
        c, p = heappop(Q)
        for np in d[p]:
            if cost[np] == 1e7:
                cost[np] = c + 1
                heappush(Q, (c + 1, np))
    return cost


n = int(eval(input()))
d = {}
for i in range(n - 1):
    a, b = list(map(int, input().split()))
    if a in d:
        d[a].append(b)
    else:
        d[a] = [b]
    if b in d:
        d[b].append(a)
    else:
        d[b] = [a]
x = BFS(1, d)[1:]
y = BFS(n, d)[1:]
# print(x,y)
F = 0
S = 0
for s, t in zip(x, y):
    if s <= t:
        F += 1
    else:
        S += 1
if F <= S:
    print("Snuke")
else:
    print("Fennec")

#
# 　　  ⋀_⋀
# 　　  (･ω･)
# .／ Ｕ ∽ Ｕ＼
#  │＊　合　＊│
#  │＊　格　＊│
#  │＊　祈　＊│
#  │＊　願　＊│
#  │＊　　　＊│
#      ￣
#
import sys

sys.setrecursionlimit(10**6)
input = sys.stdin.readline
from math import floor, sqrt, factorial, hypot, log  # log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter, defaultdict, deque
from itertools import (
    accumulate,
    permutations,
    combinations,
    product,
    combinations_with_replacement,
)
from bisect import bisect_left, bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint


def ceil(a, b):
    return (a + b - 1) // b


inf = float("inf")
mod = 10**9 + 7


def pprint(*A):
    for a in A:
        print(*a, sep="\n")


def INT_(n):
    return int(n) - 1


def MI():
    return map(int, input().split())


def MF():
    return map(float, input().split())


def MI_():
    return map(INT_, input().split())


def LI():
    return list(MI())


def LI_():
    return [int(x) - 1 for x in input().split()]


def LF():
    return list(MF())


def LIN(n: int):
    return [I() for _ in range(n)]


def LLIN(n: int):
    return [LI() for _ in range(n)]


def LLIN_(n: int):
    return [LI_() for _ in range(n)]


def LLI():
    return [list(map(int, l.split())) for l in input()]


def I():
    return int(input())


def F():
    return float(input())


def ST():
    return input().replace("\n", "")


def main():
    N = I()
    edge = [[] for _ in range(N)]
    for _ in range(N - 1):
        a, b = MI_()
        edge[a].append(b)
        edge[b].append(a)

    def bfs(start):
        q = [start]
        d = [inf] * N
        d[start] = 0
        for i in range(N):
            tmp = []
            while q:
                v = q.pop()
                for to in edge[v]:
                    if d[to] == inf:
                        tmp.append(to)
                        d[to] = i + 1
            q = tmp
        return d

    fennec = bfs(0)
    snuke = bfs(N - 1)
    f, s = 0, 0
    for i in range(N):
        if fennec[i] <= snuke[i]:
            f += 1
        else:
            s += 1
    if f > s:
        print("Fennec")
    else:
        print("Snuke")


if __name__ == "__main__":
    main()

-# 高速化heapqダイクストラ -from collections import * -from heapq import * +# +# 　　  ⋀_⋀ +# 　　  (･ω･) +# .／ Ｕ ∽ Ｕ＼ +#  │＊　合　＊│ +#  │＊　格　＊│ +#  │＊　祈　＊│ +#  │＊　願　＊│ +#  │＊　　　＊│ +#      ￣ +# -input = lambda: sys.stdin.readline() +sys.setrecursionlimit(10**6) +input = sys.stdin.readline +from math import floor, sqrt, factorial, hypot, log  # log2ないｙｐ +from heapq import heappop, heappush, heappushpop +from collections import Counter, defaultdict, deque +from itertools import ( +    accumulate, +    permutations, +    combinations, +    product, +    combinations_with_replacement, +) +from bisect import bisect_left, bisect_right +from copy import deepcopy +from fractions import gcd +from random import randint -def BFS(point, d): -    cost = [1e7] * (n + 1) -    cost[point] = 0 -    Q = [] -    heappush(Q, (0, point)) -    while Q: -        c, p = heappop(Q) -        for np in d[p]: -            if cost[np] == 1e7: -                cost[np] = c + 1 -                heappush(Q, (c + 1, np)) -    return cost +def ceil(a, b): +    return (a + b - 1) // b -n = int(eval(input())) -d = {} -for i in range(n - 1): -    a, b = list(map(int, input().split())) -    if a in d: -        d[a].append(b) +inf = float("inf") +mod = 10**9 + 7 + + +def pprint(*A): +    for a in A: +        print(*a, sep="\n") + + +def INT_(n): +    return int(n) - 1 + + +def MI(): +    return map(int, input().split()) + + +def MF(): +    return map(float, input().split()) + + +def MI_(): +    return map(INT_, input().split()) + + +def LI(): +    return list(MI()) + + +def LI_(): +    return [int(x) - 1 for x in input().split()] + + +def LF(): +    return list(MF()) + + +def LIN(n: int): +    return [I() for _ in range(n)] + + +def LLIN(n: int): +    return [LI() for _ in range(n)] + + +def LLIN_(n: int): +    return [LI_() for _ in range(n)] + + +def LLI(): +    return [list(map(int, l.split())) for l in input()] + + +def I(): +    return int(input()) + + +def F(): +    return float(input()) + + +def ST(): +    return input().replace("\n", "") + + +def main(): +    N = I() +    edge = [[] for _ in range(N)] +    for _ in range(N - 1): +        a, b = MI_() +        edge[a].append(b) +        edge[b].append(a) + +    def bfs(start): +        q = [start] +        d = [inf] * N +        d[start] = 0 +        for i in range(N): +            tmp = [] +            while q: +                v = q.pop() +                for to in edge[v]: +                    if d[to] == inf: +                        tmp.append(to) +                        d[to] = i + 1 +            q = tmp +        return d + +    fennec = bfs(0) +    snuke = bfs(N - 1) +    f, s = 0, 0 +    for i in range(N): +        if fennec[i] <= snuke[i]: +            f += 1 +        else: +            s += 1 +    if f > s: +        print("Fennec") -        d[a] = [b] -    if b in d: -        d[b].append(a) -    else: -        d[b] = [a] -x = BFS(1, d)[1:] -y = BFS(n, d)[1:] -# print(x,y) -F = 0 -S = 0 -for s, t in zip(x, y): -    if s <= t: -        F += 1 -    else: -        S += 1 -if F <= S: -    print("Snuke") -else: -    print("Fennec") +        print("Snuke") + + +if __name__ == "__main__": +    main()