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

//using namespace std;

//const int MAXN=100005;

//int N;

//vector<int>adj[MAXN];

//int dist[2][MAXN];

//int type;

//int cnt;

//void dfs(int i,int last=-1)

//{

//	if(last!=-1)

//		dist[type][i]=dist[type][last]+1;

//	for(int j=0;j<adj[i].size();j++)

//		if(adj[i][j]!=last)

//			dfs(adj[i][j],i);

//}

//int main()

//{

//	scanf("%d",&N);

//	for(int i=0;i<N-1;i++)

//	{

//		int x,y;

//		scanf("%d%d",&x,&y);

//		adj[x].push_back(y);

//		adj[y].push_back(x);

//	}

//	type=0;

//	dfs(1);

//	type=1;

//	dfs(N);

//	for(int i=1;i<=N;i++)

//		if(dist[0][i]<=dist[1][i])

//			cnt++;

//	printf("%s\n",cnt>N/2?"Fennec":"Snuke");

//	return 0;

//}

#include<bits/stdc++.h>

using namespace std;

const int MAXN=1e5+5;

int N;

int frst;

vector<int>adj[MAXN];

vector<int>vec;

int cnt[MAXN];

void dfs(int i,int last)

{

	cnt[i]=1;

	vec.push_back(i);

	if(i==N)

		frst=vec[(vec.size()+1)/2];

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

	{

		if(adj[i][j]==last)

			continue;

		dfs(adj[i][j],i);

		cnt[i]+=cnt[adj[i][j]];

	}

	vec.pop_back();

}

int main()

{

	scanf("%d",&N);

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

	{

		int x,y;

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

		adj[x].push_back(y);

		adj[y].push_back(x);

	}

	dfs(1,0);

	printf("%s\n",cnt[frst]*2>=N?"Snuke":"Fennec");

	return 0;

}

// Optimized solution to the same problem (faster):
//	Fennec and Snuke are playing a board game.

//	On the board, there are N cells numbered 1 through N,and N-1 roads, each connecting two cells. Cell ai is adjacent to Cell bithrough the i-th 

//road. Every cell can be reached from every other cell by repeatedly traveling to an adjacent cell. In terms of graph theory, the graph formed by

//the cells and the roads is a tree.

//	Initially, Cell 1 is painted black, and Cell N is. The other cells are not yet colored.Fennec (who goes first) and Snuke (who goes second) 

//alternately paint an uncolored cell. More specifically, each player performs the following action in her/his turn:

//	Fennec: selects an uncolored cell that is adjacent to a black cell, and paints it black.

//	Snuke: selects an uncolored cell that is adjacent to a white cell, and paints it white.

//	A player loses when she/he cannot paint a cell. Determine the winner of the game when Fennec and Snuke play optimally.

//		2<=N<1e5;



//AC:

//#include<bits/stdc++.h>

//using namespace std;

//const int MAXN=100005;

//int N;

//vector<int>adj[MAXN];

//int dist[2][MAXN];

//int type;

//int cnt;

//void dfs(int i,int last=-1)

//{

//	if(last!=-1)

//		dist[type][i]=dist[type][last]+1;

//	for(int j=0;j<adj[i].size();j++)

//		if(adj[i][j]!=last)

//			dfs(adj[i][j],i);

//}

//int main()

//{

//	scanf("%d",&N);

//	for(int i=0;i<N-1;i++)

//	{

//		int x,y;

//		scanf("%d%d",&x,&y);

//		adj[x].push_back(y);

//		adj[y].push_back(x);

//	}

//	type=0;

//	dfs(1);

//	type=1;

//	dfs(N);

//	for(int i=1;i<=N;i++)

//		if(dist[0][i]<=dist[1][i])

//			cnt++;

//	printf("%s\n",cnt>N/2?"Fennec":"Snuke");

//	return 0;

//}



//AC:

//#include<bits/stdc++.h>

//using namespace std;

//const int MAXN=1e5+5;

//int N;

//int frst;

//vector<int>adj[MAXN];

//vector<int>vec;

//int cnt[MAXN];

//void dfs(int i,int last)

//{

//	cnt[i]=1;

//	vec.push_back(i);

//	if(i==N)

//		frst=vec[(vec.size()+1)/2];

//	for(int j=0;j<adj[i].size();j++)

//	{

//		if(adj[i][j]==last)

//			continue;

//		dfs(adj[i][j],i);

//		cnt[i]+=cnt[adj[i][j]];

//	}

//	vec.pop_back();

//}

//int main()

//{

//	scanf("%d",&N);

//	for(int i=0;i<N-1;i++)

//	{

//		int x,y;

//		scanf("%d%d",&x,&y);

//		adj[x].push_back(y);

//		adj[y].push_back(x);

//	}

//	dfs(1,0);

//	printf("%s\n",cnt[frst]*2>=N?"Snuke":"Fennec");

//	return 0;

//}



//#include<bits/stdc++.h>

//#define pb push_back

//using namespace std;

//const int MAXN=1e5+5;

//int N;

//void dfs(int u,vector<vector<long long>>)qw

//int main()

//{

//	

//	return 0;

//}



#include<bits/stdc++.h>

#define pb push_back

using namespace std;

typedef long long ll;

const int MAXN=1e5+5;

int n;

int ghead[100000],gnxt[199998],gto[199998];

int path[100000],npath;

int col[100000];

bool dfs(int at,int par)

{

	if(at==n-1){npath=0;path[npath++]=at;return true;}

	for(int x=ghead[at];x!=-1;x=gnxt[x])

	{

		int to=gto[x];if(to==par)continue;

		if(dfs(to,at)){path[npath++]=at;return true;}

	}

	return false;

}

void dfscol(int at,int par)

{

	for(int x=ghead[at];x!=-1;x=gnxt[x])

	{

		int to=gto[x];if(to==par||col[to]!=-1)continue;

		col[to]=col[at];dfscol(to,at);

	}

}

int main()

{

	scanf("%d",&n);

	memset(ghead,-1,sizeof(ghead));

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

	{

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

		gnxt[2*i+0]=ghead[a],ghead[a]=2*i+0,gto[2*i+0]=b;

		gnxt[2*i+1]=ghead[b],ghead[b]=2*i+1,gto[2*i+1]=a;

	}

	assert(dfs(0,-1));

	reverse(path,path+npath);

	memset(col,-1,sizeof(col));

	for(int i=0;i<npath;i++)col[path[i]]=i<(npath+1)/2?0:1;

	for(int i=0;i<npath;i++)dfscol(path[i],-1);

	int na=0;

	for(int i=0;i<n;i++)if(col[i]==0)na++;

	printf("%s\n",na>(n-na)?"Fennec":"Snuke");

	return 0;

}

// Fastest known solution for this problem: