// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



typedef long long ll;

const int maxn=1e5+7;

const int inf=1e9+7;

const int mod=1e9+7;

#define pb push_back

#define pii pair<int,int>

#define F first

#define S second

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

#define rep2(i,a,b) for (int i=(a);i<=(b);i++)



vector <int> G[maxn];

set <int> fennec,snuck;

vector<int> color;

bool v[maxn]={0};

int sub[maxn]={0};



bool dfs (int now,int target)

{ v[now]=1;

if (now==target) {

	color.pb(now);

	return 1;

}

	for (int i:G[now])

	{

		if (!v[i])

		{

			if (dfs(i,target)) 

			{

			color.pb(now);

			return 1;

			}

		}

	}

	return 0;

} 



int dfs2(int now)

{

	v[now]=1;

	int sum=0;

	for (int i:G[now])

	{

		if (!v[i])

		{

			if (fennec.find(i)==fennec.end()&&

			snuck.find(i)==snuck.end())

			{

			sum+=1;

			//cout<<now<<' '<<i<<endl;

			sum+=dfs2(i);

			}

			else dfs2(i);

		}

	}

	sub[now]=sum;

	return sum;

} 



int main()

{

 	ios::sync_with_stdio(0); cin.tie(0);

 	int n;

 	cin>>n;

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

 	{

 		int a,b;

 		cin>>a>>b;

 		G[a].pb(b);

 		G[b].pb(a);

	}

	//cout<<"---"<<endl;

	dfs(1,n);

	memset(v,0,sizeof(v));

	int size=color.size();

	for (int i=0;i<size;i++)

	{

		//cout<<color[i]<<' ';

		if ((i+1)<=size/2) snuck.insert(color[i]);

		else fennec.insert(color[i]);

	}

	dfs2(1);

	int sums=0,sumf=0;

	//for (int i=1;i<=n;i++) cout<<sub[i]<<' ';

	for (auto j=snuck.begin();j!=snuck.end();j++)

	{ /*cout<<sub[(*j)]<<'/'; */sums+=sub[(*j)];}

	 for (auto j=fennec.begin();j!=fennec.end();j++)

	{/*cout<<sub[(*j)]<<'*';*/sumf+=sub[(*j)];}

	if (sumf+size-size/2>sums+size/2) cout<<"Fennec"<<endl;

	else cout<<"Snuke"<<endl;

}

// 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: