// Slower C++ solution:
/////////////////////////////////////////

////////// ^\/^ *_* :) :-D '~' \\\\\\\\\\

/////////////////////////////////////////

#include <bits/stdc++.h>

//#include <algorithm>

//#include <cstdio>

//#include <functional>

#include <iostream>

//#include <cfloat>

//#include <climits>

//#include <cstdlib>

//#include <cstring>

//#include <cmath>

//#include <map>

//#include <queue>

//#include <set>

//#include <sstream>

//#include <stack>

//#include <string>

//#include <time.h>

//#include <vector>

//#include <random>

//#include <unordered_set>

//#include <complex>

//#include <string.h>



#define rt0 return 0

#define rep(i,n) for(int i=0;i<n;i++)

#define repn(i,n) for(int i=1;i<=n;i++)

#define LL long long

#define pii pair<int,int>

#define pb push_back

#define fi first

#define se second

#define mpr make_pair



using namespace std;



const LL MOD=1e9+7;

int n,dist[100010],dist2[100010];

vector <int> g[100010];



int main()

{

	cin>>n;

	rep(i,n-1)

	{

		int x,y;

		cin>>x>>y;

		g[x].pb(y);

		g[y].pb(x);

	}

	memset(dist,1,sizeof(dist));

	memset(dist2,1,sizeof(dist2));

	queue <int> q;

	dist[1]=0;

	q.push(1);

	while(!q.empty())

	{

		int t=q.front();

		q.pop();

		rep(i,g[t].size())

		{

			if(dist[g[t][i]]!=16843009) continue;

			else

			{

				dist[g[t][i]]=dist[t]+1;

				q.push(g[t][i]);

			}

		}

	}

	queue <int> q1;

	dist2[n]=0;

	q1.push(n);

	while(!q1.empty())

	{

		int t=q1.front();

		q1.pop();

		rep(i,g[t].size())

		{

			if(dist2[g[t][i]]!=16843009) continue;

			else

			{

				dist2[g[t][i]]=dist2[t]+1;

				q1.push(g[t][i]);

			}

		}

	}

	int fen=0,snu=0;

	repn(i,n)

	{

		if(dist[i]<=dist2[i]) fen++;

		else snu++;

	}

	if(fen>snu) puts("Fennec");

	else puts("Snuke");

	rt0;

}

// Faster C++ solution for the same problem (measured speedup: 1.2410381216136719x):
#include <stdio.h>

#include <string.h>

#include <math.h>

#include <iostream>

#include <algorithm>

#include <vector>

#include <set>

#include <map>

#include <queue>

#include <unordered_map>

using namespace std;



typedef long long ll;

typedef pair<int, int> pii;



const int maxn = 1e5 + 10;

const int INF = 0x3f3f3f3f;

const ll LL_INF = 0x3f3f3f3f3f3f3f3f;



#define dbg(x1) cout<<#x1<<" = "<<(x1)<<endl

#define dbg2(x1,x2) cout<<#x1<<" = "<<(x1)<<" "<<#x2<<" = "<<(x2)<<endl

#define dbg3(x1,x2,x3) cout<<#x1<<" = "<<(x1)<<" "<<#x2<<" = "<<(x2)<<" "<<#x3<<" = "<<(x3)<<endl



int n;

vector<int> G[maxn];

bool mark[maxn];

int from[maxn], sz[maxn];



void addedge(int u, int v) {

    G[u].push_back(v);

}



void dfs(int id, int fa) {

    sz[id] = 1;

    for (auto v: G[id]) {

        if (v == fa) continue;

        dfs(v, id);

        sz[id] += sz[v];

        from[v] = id;

    }

}



vector<int> ve;



int main() {

    //freopen(".in", "r", stdin);

    scanf("%d", &n);

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

        int u, v;

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

        addedge(u, v);

        addedge(v, u);

    }

    mark[n] = true;

    dfs(1, -1);

    int pos = n;

    while (pos) {

        ve.push_back(pos);

        pos = from[pos];

    }

    reverse(ve.begin(), ve.end());

    int len = ve.size();

    int A, B;

    if (len & 1) {

        A = sz[ve[(int)ve.size() / 2 + 1]];

        B = n - A;

    } else {

        A = sz[ve[(int)ve.size() / 2]];

        B = n - A;

    }

    if (A + 1 <= B) puts("Fennec");

    else puts("Snuke");

    return 0;

}