// Slower C++ solution:
#include<iostream>

#include<iomanip>

#include<cmath>

#include<string>

#include<cctype>

#include<algorithm>

#include<set>

#include<map>

#include<stack>

#include<queue>

#include<cstring>

#include<list>

//#include<windows.h>

//#include<time.h>

#define pb push_back

#define ppb pop_back

#define fi first

#define se second

#define mer make_pair

#define mme memset

#define ao(a) (a.begin(),a.end())

using namespace std;



const double pie1=3.1415926;//π1

const double pie2=3.14159265358979;//π2

const double pie3=3.14159265358979323846;//π3

const int vbi=999999999;

const int vli=-vbi;

const long long vbl=999999999999999999;

const long long vll=-vbl;



typedef long long ll;

typedef pair<int,int> pii;

typedef pair<ll,ll> pll;

typedef pair<pii,int> piii;

typedef pair<pii,pii> pi4;

typedef pair<pll,ll> plll;

typedef pair<int,pii> ipii;

typedef pair<ll,pll> lpll;

typedef pair<pll,pll> pl4;

typedef vector<int> vi;

typedef vector<ll> vl;

typedef vector<pii> vpi;

typedef vector<pll> vpl;

typedef set<int> sti;

typedef set<ll> stl;

typedef set<pii> spi;

typedef set<pll> spl;

priority_queue<int> pqi;

priority_queue<ll> pql;

queue<int> qi;

queue<ll> ql;



/*void bin_v(){

	char bin[1000];

	gets(bin);

}*/



bool pss(int a){

	for(int i=2;i<=sqrt(a);i++)

		if(a%i==0)

			return false;

	return true;

}

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



int n,m;

vector<int> v[100010];

vector<int> lj;

int sss[100010];

int fi;



bool dfs(int now,int last){

	lj.pb(now);

	sss[now]=1;

	if(now==n){

		fi=lj[(lj.size()+1)/2];

	}

	for(int i=0;i<v[now].size();i++)

		if(v[now][i]!=last){

			dfs(v[now][i],now);

			sss[now]+=sss[v[now][i]];

		}

	lj.ppb();

	return false;

}



int main(){

	//my name is Veex_WCY

	ios::sync_with_stdio(false);

	cin>>n;

	m=n-1;

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

		int a,b;

		cin>>a>>b;

		v[a].pb(b);

		v[b].pb(a);

	}

	dfs(1,-1);

	if(sss[fi]*2<n)

		cout<<"Fennec";

	else

		cout<<"Snuke";

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 3.51387878800354x):
#define _USE_MATH_DEFINES

#include <algorithm>

#include <array>

#include <bitset>

#include <cassert>

#include <cctype>

#include <climits>

#include <clocale>

#include <cmath>

#include <complex>

#include <cstdio>

#include <cstdlib>

#include <ctime>

#include <deque>

#include <fstream>

#include <functional>

#include <iomanip>

#include <iostream>

#include <iterator>

#include <list>

#include <map>

#include <numeric>

#include <queue>

#include <regex>

#include <set>

#include <sstream>

#include <stack>

#include <string>

#include <tuple>

#include <unordered_map>

#include <unordered_set>

#include <utility>

#include <vector>



const int MOD = 1000000007; 

const int INF = 1000000000; //1e9

const int NIL = -1;

const long long LINF = 1000000000000000000; // 1e18

const long double EPS = 1E-10;



template<class T, class S> inline bool chmax(T &a, const S &b){

    if(a < b){

        a = b; return true;

    }

    return false;

}

template<class T, class S> inline bool chmin(T &a, const S &b){

    if(b < a){

        a = b; return true;

    }

    return false;

}









int main(){

    int N; std::cin >> N;

    std::vector<std::vector<int>> G(N);

    std::vector<int> d0(N, -1), dN(N, -1);

    {

        int a, b;

        for(int i(0), i_len(N-1); i < i_len; ++i){

            std::cin >> a >> b;

            --a; --b;

            G[a].push_back(b);

            G[b].push_back(a);

        }

    }

    d0[0] = 0;

    std::queue<int> que;

    que.push(0);

    while(!que.empty()){

        int v(que.front()); que.pop();

        for(int e: G[v]){

            if(d0[e] != -1) continue;

            d0[e] = d0[v] + 1;

            que.push(e);

        }

    }

    dN[N-1] = 0;

    que.push(N-1);

    while(!que.empty()){

        int v(que.front()); que.pop();

        for(int e: G[v]){

            if(dN[e] != -1) continue;

            dN[e] = dN[v] + 1;

            que.push(e);

        }

    }

    int cnt(0);

    for(int i(0); i < N; ++i){

        if(d0[i] <= dN[i]) ++cnt; 

    }

    std::cout << ((2*cnt > N) ? "Fennec": "Snuke") << std::endl;

    return 0;

}