// Original C++ solution (slower):
#include<iostream>

#include<string>

#include<stdlib.h> 

#include<cstring>

#include<map>

#include<list>

#include<stdio.h>

#include<cmath>

#include<iomanip>

#include<bitset>

#include<vector>

#include<time.h>

#include<algorithm> 

#include<queue>

#include<set>

#include<deque>

#define mod 1e9+7

#define inf 1e18 

typedef long long ll;

typedef long double ld;

using namespace std;

typedef list<ll> li;

typedef list<ll>::iterator lt;

li sh_r;

ll N,s;

vector<li>a;

bool dfs(ll step,ll x,ll f){

	if(x>N)cout<<f<<" "<<x<<endl;

	if(x==N){

	  s=step;

	  return true;

    }

	for(lt it=a[x].begin();it!=a[x].end();it++){

		if(*it==f)continue;

		if(dfs(step+1,*it,x)){

			sh_r.push_back(x);

			return true;

		}

	}

	return false;

}

ll num(ll x,ll f){

	ll n=1;

	for(lt it=a[x].begin();it!=a[x].end();it++){

		if(*it==f)continue;

		n+=num(*it,x);

	}

	return n;

}

int main(){	

    cin>>N;

    a.resize(N+10);

    for(ll K=1;K<N;K++){

    	ll x,y;

    	scanf("%lld%lld",&x,&y);

    	a[x].push_back(y);

    	a[y].push_back(x);

	}

	dfs(0,1,-1);

	s--;

	ll F=1,S=N;

	if(N!=2){

		ll j=s/2;

		for(lt it=sh_r.begin();it!=sh_r.end();it++){

			j--;

			if(j==0)S=*it;

			if(j==-1){

				F=*it;

				break;

			}

		}

	}

	ll Fen=num(F,S);

	ll Snu=num(S,F);

	if(Fen>Snu)printf("Fennec");

	else printf("Snuke");

	return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <cstring>

using namespace std;



int first[100003], next[200003], node[200003], n, len, ans[3], m;

char fs[100003];

bool vis[100003];



inline void readin(int n)

{

    int p = 1;

    for (int i = 1; i < n; ++i)

    {

        int u, v;

        scanf("%d%d", &u, &v);

        next[p] = first[u];

        first[u] = p;

        node[p] = v;

        ++p;

        next[p] = first[v];

        first[v] = p;

        node[p] = u;

        ++p;

    }

}



bool dfs(int x, int deep)

{

    vis[x] = true;

    if (x == n)

    {

        len = deep >> 1;

        fs[n] = 2;

        ++ans[2];

        return true;

    }

    int t = first[x];

    while (t)

    {

        if (!vis[node[t]])

        {

            if (dfs(node[t], deep + 1))

            {

                if (deep > len)

                {

                    fs[x] = 2;

                    ++ans[2];

                }

                else

                {

                    fs[x] = 1;

                    ++ans[1];

                }

                return true;

            }

        }

        t = next[t];

    }

    return false;

}



void ddfs(int x)

{

    int t = first[x];

    while (t)

    {

        if (fs[node[t]] == 0)

        {

            ++ans[m];

            fs[node[t]] = m;

            ddfs(node[t]);

        }

        t = next[t];

    }

}



void init()

{

    memset(first, 0, sizeof first);

    memset(ans, 0, sizeof ans);

    memset(fs, 0, sizeof fs);

    memset(vis, false, sizeof vis);

}



int main()

{

    while (scanf("%d", &n) != EOF)

    {

        readin(n);

        dfs(1, 0);

        for (int i = 1; i <= n; ++i)

        {

            if (fs[i])

            {

                m = fs[i];

                ddfs(i);

            }

        }

        printf("%s\n", ans[1] > ans[2] ? "Fennec" : "Snuke");

        init();

    }

}

// Fastest known solution for this problem: