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

using namespace std;

const int TAM = 100003;



vector <int> adj[TAM];

int n, a, b, vis[TAM];

int pa [TAM], pb [TAM], sub[TAM], col[TAM];



int calc ( int x ){

    sub[x] = 1;

    for( int i = 0 ; i < adj[x].size() ; i ++ ){

        if( adj[x][i] == pa[x] ) continue;

        sub[x] += calc(adj[x][i]);

    }

    //cout << " calc :: " << x << " -> " << sub[x] << endl ;

    return sub[x];

}



int main(){



    scanf("%d",&n);

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

        scanf("%d%d",&a,&b);

        adj[a].push_back(b);

        adj[b].push_back(a);

    }

    queue <int> bfs;

    bfs.push(1);

    pa[1] = 1;

    vis[1] = 1;

    int act, nxt;

    while( bfs.size() ){

        act = bfs.front();

        bfs.pop();



        for( int i = 0 ; i < adj[act].size() ; i ++ ){

            nxt = adj[act][i];

            if( vis[nxt] != 1 ){

                vis[nxt] = 1;

                pa[nxt] = act;

                //cout << " pa :: " << nxt << " -> " << pa[nxt] << endl ;

                bfs.push(nxt);

            }

        }

    }

    calc(1);



    bfs.push(n);

    pb[n] = n;

    vis[n] = 2;

    while( bfs.size() ){

        act = bfs.front();

        bfs.pop();



        for( int i = 0 ; i < adj[act].size() ; i ++ ){

            nxt = adj[act][i];

            if( vis[nxt] != 2 ){

                vis[nxt] = 2;

                pb[nxt] = act;

                //cout << " pb :: " << nxt << " -> " << pb[nxt] << endl ;

                bfs.push(nxt);

            }

        }

    }



    col[1] = 1;

    col[n] = 2;

    int ta = 1, tb = 1, ca = 1, cb = n, ra, rb;

    while( true ){

        if( col[pb[ca]] == 0 ){

            ca = pb[ca];

            col[ca] = 1;

            ta ++;

        }else{

            ra = sub[1] - sub[cb] - ta;

            rb = sub[cb] - tb;

            if( ra > rb ) printf("Fennec\n");

            else printf("Snuke\n");

            return 0;

        }

        if( col[pa[cb]] == 0 ){

            cb = pa[cb];

            col[cb] = 2;

            tb ++;

        }else{

            ra = sub[1] - sub[cb] - ta;

            rb = sub[cb] - tb;

            if( ra >= rb ) printf("Fennec\n");

            else printf("Snuke\n");

            return 0;

        }

    }



    return 0;

}


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

#include<vector>

#include<algorithm>

using namespace std;

typedef unsigned uint;

int inline in(){int x=0,c;for(;(uint)((c=getchar())-'0')>=10;)

{if(c=='-')return -in();if(!~c)throw ~0;}do{x=(x<<3)+(x<<1)+(c-'0');}

while((uint)((c=getchar())-'0')<10);return x;}

int n;

void dfs(int u,vector<vector<int> >&E,vector<int>&p,vector<int>&sz){

	sz[u]=1;

	for(int i=0;i<(int)E[u].size();i++){

		int to=E[u][i];

		if(p[u]!=to){

			p[to]=u;

			dfs(to,E,p,sz);

			sz[u]+=sz[to];

		}

	}

}

int main(){

    n=in();

	vector<vector<int> >E(n);

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

		int a,b;

		a=in();b=in();

		a--;b--;

		E[a].push_back(b);

		E[b].push_back(a);

	}

	vector<int> p(n,-1),sz(n,0);

	dfs(0,E,p,sz);

	vector<int>path;

	int c=n-1,psz=0;

	while(c>=0){

		path.push_back(sz[c]-psz);

		psz=sz[c];

		c=p[c];

	}

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

	int ls=0;

	for(int i=0;i<((int)path.size()+1)/2;i++){

		ls+=path[i];

	}

	if(2*ls>n)printf("Fennec");

	else printf("Snuke");

	return 0;

}

// Fastest known solution for this problem: