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

 *   I<3   C++   *

 *  IWANT ANYAC  *

 * ILOVEPROGRAM! *

 *IT'SINTERESTING*

 * ILOVEPROGRAM! *

 *  INCONTESTS   *

 *   GETSCORE    *

 *    ACCODE     *

 *     LETS      *

 *      GO       *

 *****************/

#include <algorithm>

#include <bitset>

#include <cassert>

#include <cctype>

#include <cmath>

#include <complex>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>

#include <deque>

#include <fstream>

#include <functional>

#include <iomanip>

#include <iostream>

#include <list>

#include <map>

#include <numeric>

#include <queue>

#include <set>

#include <sstream>

#include <stack>

#include <string>

#include <utility>

#include <vector>

#define LL long long

#define pb push_back

#define pob pop_back

#define mp make_pair

#define FILL(a,v) memset((void*)a,v,sizeof(a))

#define FILL0(a) FILL(a,0)

#define FILL1(a) FILL(a,-1)

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

#define Inf 1e9

#define Mod 1000000007

#define foreach(it,x) for(typeof(x.begin()) it=x.begin();it!=x.end();it++)

#define FOR(i,x) for(int i=0;i<x;i++)

#define RFOR(i,x) for(int i=x-1;i>=0;i--)

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

#define FRFOR(i,a,b) for(int i=a-1;i>=b;i--)

#define SZ(a) ((int)(a).size())

#define FI first

#define SE second

#define OVER(a) return puts(a),0

#define fastio ios::sync_with_stdio(0)

#define filei(f) freopen(f,"r",stdin)

#define fileo(f) freopen(f,"w",stdout)

#define MASK(a) (1<<(a))

#define MASKX(x,a) ((x)<<(a))

#define BIT(a,b) ((a>>b)&1)

using namespace std;

typedef pair<int,int> pii;

typedef unsigned long long UINT;

typedef unsigned int Uint;

typedef long long INT;

typedef pair<INT,INT> PII;

typedef stringstream sst;

typedef istringstream iss;

typedef vector<int> vint;

typedef vector<INT> VINT;

typedef vector<pii> vpii;

typedef vector<PII> VPII;

typedef priority_queue<int> pqi;

typedef priority_queue<INT> PQI;

typedef priority_queue<pii> pqp;

typedef priority_queue<PII> PQP;

typedef priority_queue<int,vint,greater<int> > xqi;

typedef priority_queue<INT,VINT,greater<INT> > XQI;

typedef priority_queue<pii,vpii,greater<pii> > xqp;

typedef priority_queue<PII,VPII,greater<PII> > XQP;



int n,fromst;

vector<int> jian,nei[100007];

int dis[100007],cnt[100007];



int dfs(int la,int a)

{

	int cn=1;

	jian.push_back(a);

	if(a==n-1)fromst=jian[(SZ(jian)+1)/2];

	for(int i=0;i<SZ(nei[a]);i++)

		if(nei[a][i]!=la)

			cn+=dfs(a,nei[a][i]),dis[nei[a][i]]=dis[a]+1;

	jian.pop_back();

	cnt[a]=cn;

	return cn;

}



int a,b;



int main()

{

	scanf("%d",&n);

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

	{

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

		nei[a-1].push_back(b-1);

		nei[b-1].push_back(a-1);

	}

	dfs(-1,0);

	string mark;

	if(cnt[fromst]>=(n+1)/2)mark="Snuke";

	else mark="Fennec";

	cout<<mark<<endl;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.5096294902746417x):
// È¥°É£¡Æ¤¿¨Çð! °ÑAC´ø»ØÀ´£¡

//      ¤Ø¡¡¡¡¡¡¡¡¡¡£¯|

// ¡¡¡¡/£Ü7¡¡¡¡¡¡ ¡Ï£ß/

// ¡¡ /¡¡©¦¡¡¡¡ £¯¡¡£¯								AC		AC		AC		AC

//    ©¦¡¡Z £ß,£¼¡¡£¯¡¡¡¡ /`©c						AC		AC		AC		AC

//    ©¦¡¡¡¡¡¡¡¡¡¡©c¡¡¡¡ /¡¡¡¡¡µ					AC		AC		AC		AC

// ¡¡Y¡¡¡¡¡¡¡¡¡¡`¡¡ /¡¡¡¡/  /						AC		AC		AC		AC

// ¡¡Øé¡ñ¡¡.¡¡¡ñ¡¡¡¡¡´¡¡/¡¡/						AC		AC		AC		AC

// ¡¡()¡¡ ¤Ø¡¡¡¡¡¡¡¡|¡¡£Ü¡´							AC		AC		AC		AC

// ¡¡¡¡>- ._¡¡ ¥£¡¡ ©¦ £¯£¯							AC		AC		AC		AC

// ¡¡ / ¤Ø¡¡¡¡ /¡¡/£¼| £Ü£Ü							AC		AC		AC		AC

// ¡¡ ©c_/¡¡¡¡(_£¯¡¡ ©¦£¯£¯							AC		AC		AC		AC

// ¡¡¡¡ 7¡¡¡¡¡¡¡¡¡¡¡¡¡¡|£¯							AC		AC		AC		AC

// ¡¡¡¡ £¾¨Dr£þ£þ`-¨D£ß/							AC		AC		AC		AC

//**************************************Accepted*****************************************//



#include<bits/stdc++.h>



#define all(x) x.begin(),x.end()

#define pb push_back

#define mp make_pair

#define Unique(x) x.erase(unique(all(x)),x.end());



#define CIN_FILE "input.txt"

#define COUT_FILE "output.txt"



#define Pig (OO)



using namespace std;



const int dx[]={-1,0,1,0};

const int dy[]={0,-1,0,1};



inline int read()

{

	#define gc getchar

	int ans=0;

	bool f=1;

	char ch=gc();

	

	while(!isdigit(ch))f^=ch=='-',ch=gc();

	

	while(isdigit(ch))ans=((ans<<2)+ans<<1)+(ch^48),ch=gc();

	

	return f?ans:-ans;

	

	#undef gc

}



typedef long long ll;



/*



template <typename T>

struct modular {

    constexpr modular() : val(0){}

    constexpr modular(const modular<T>& _m) : val(_m.val) {}

    template <typename U> constexpr modular(const U& _r = U()) {

        val = -MOD <= _r && _r < MOD ? _r: _r % MOD;

        if (val < 0) { val += MOD; } }

    const T operator()() { return val; }

    template <typename U> explicit operator U() const { return static_cast<U>(val); }

    modular<T>& operator+=(const modular<T>& _m) { if ((val += _m.val) >= MOD) { val -= MOD; } return *this; }

    modular<T>& operator-=(const modular<T>& _m) { if ((val -= _m.val) < 0) { val += MOD; } return *this; }

    modular<T>& operator*=(const modular<T>& _m) { val = modular<T>(static_cast<int64_t>(val) * static_cast<int64_t>(_m.val)).val; return *this; }

    modular<T>& operator/=(const modular<T>& _m) {

        T a = _m.val, b = MOD, u = 0, v = 1;

        while (a != 0) {

            T q = b / a;

            b -= q * a; swap(a, b);

            u -= q * v; swap(u, v);

        } return *this *= u; }

    modular<T>& operator =(const modular<T>& _m) { val = _m.val; return *this; }

    template <typename U> modular<T>& operator+=(const U& _r) { return *this += modular<T>(_r); }

    template <typename U> modular<T>& operator-=(const U& _r) { return *this -= modular<T>(_r); }

    template <typename U> modular<T>& operator*=(const U& _r) { return *this *= modular<T>(_r); }

    template <typename U> modular<T>& operator/=(const U& _r) { return *this /= modular<T>(_r); }

    template <typename U> modular<T>& operator =(const U& _r) { val = modular<T>(_r).val; return *this; }

    modular<T> operator-() { return modular<T>(-val); }

    template <typename U> friend bool operator==(const modular<U>&, const modular<U>&);

    friend std::istream& operator>>(std::istream& os, modular<T>& _m) { os >> _m.val; _m *= 1; return os; }

    friend std::ostream& operator<<(std::ostream& os, const modular<T>& _m) { return os << _m.val; }

    template <typename U>

    modular<T> exp(U e) {

        modular<T> res = 1;

        modular<T> b = val;

        if (e < 0) { b = 1/b; e *= -1; }

        for (; e; e >>= 1) {

            if (e & 1) { res *= b; }

            b *= b;

        } return res; }

private:

    T val;

};

template <typename T> inline modular<T> operator+(const modular<T>& _lhs, const modular<T>& _rhs) { return modular<T>(_lhs) += _rhs; }

template <typename T, typename U> inline modular<T> operator+(const modular<T>& _lhs, const U& _rhs) { return modular<T>(_lhs) += _rhs; }

template <typename T, typename U> inline modular<T> operator+(const U& _lhs, const modular<T>& _rhs) { return modular<T>(_lhs) += _rhs; }

template <typename T> inline modular<T> operator-(const modular<T>& _lhs, const modular<T>& _rhs) { return modular<T>(_lhs) -= _rhs; }

template <typename T, typename U> inline modular<T> operator-(const modular<T>& _lhs, const U& _rhs) { return modular<T>(_lhs) -= _rhs; }

template <typename T, typename U> inline modular<T> operator-(const U& _lhs, const modular<T>& _rhs) { return modular<T>(_lhs) -= _rhs; }

template <typename T> inline modular<T> operator*(const modular<T>& _lhs, const modular<T>& _rhs) { return modular<T>(_lhs) *= _rhs; }

template <typename T, typename U> inline modular<T> operator*(const modular<T>& _lhs, const U& _rhs) { return modular<T>(_lhs) *= _rhs; }

template <typename T, typename U> inline modular<T> operator*(const U& _lhs, const modular<T>& _rhs) { return modular<T>(_lhs) *= _rhs; }

template <typename T> inline modular<T> operator/(const modular<T>& _lhs, const modular<T>& _rhs) { return modular<T>(_lhs) /= _rhs; }

template <typename T, typename U> inline modular<T> operator/(const modular<T>& _lhs, const U& _rhs) { return modular<T>(_lhs) /= _rhs; }

template <typename T, typename U> inline modular<T> operator/(const U& _lhs, const modular<T>& _rhs) { return modular<T>(_lhs) /= _rhs; }

template <typename T> inline bool operator==(const modular<T>& _lhs, const modular<T>& _rhs) { return _lhs.val == _rhs.val; }

template <typename T, typename U> inline bool operator==(const modular<T>& _lhs, const U& _rhs) { return _lhs == modular<T>(_rhs); }

template <typename T, typename U> inline bool operator==(const U& _lhs, const modular<T>& _rhs) { return modular<T>(_lhs) == _rhs; }

template <typename T> inline bool operator!=(const modular<T>& _lhs, const modular<T>& _rhs) { return !(_lhs == _rhs); }

template <typename T, typename U> inline bool operator!=(const modular<T>& _lhs, const U& _rhs) { return !(_lhs == _rhs); }

template <typename T, typename U> inline bool operator!=(const U& _lhs, const modular<T>& _rhs) { return !(_lhs == _rhs); }

typedef modular<int> mint;



*/



int n;



int ghead[100010];

int gnext[200010];

int gto[200010];



int path[100010];

int npath;



int col[100010];



bool DFS(int x,int pre)

{

	if(x==n-1)

	{

		npath=0;

		path[npath++]=x;

		

		return 1;

	}

	

	for(int v=ghead[x];v!=-1;v=gnext[v])

	{

		int to=gto[v];

		

		if(to==pre)continue;

		else

		{

			if(DFS(to,x))

			{

				path[npath++]=x;

				

				return 1;

			}

			else continue;

		}

	}

	

	return 0;

}



void DFScol(int x,int pre)

{

	for(int v=ghead[x];v!=-1;v=gnext[v])

	{

		int to=gto[v];

		

		if(to==pre||col[to]!=-1)continue;

		else

		{

			col[to]=col[x];

			

			DFScol(to,x);

		}

	}

}



void Add(int x,int y,int flag,int i)

{

	gnext[2*i+flag]=ghead[x];

	ghead[x]=2*i+flag;

	gto[2*i+flag]=y;

}



int cnt1,cnt2;



int main(int argc, char const *argv[])

{

	ios::sync_with_stdio(false);

	

	scanf("%d",&n);

	

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

	

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

	{

		int x,y;

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

		

		x--,y--;

		

		Add(x,y,0,i);

		Add(y,x,1,i);

	}

	

	assert(DFS(0,-2));

	

	reverse(path,path+npath);

	

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

	

	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);

	

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

	{

		if(col[i]==0)cnt1++;

		else cnt2++;

	}

	

	printf("%s",(cnt1>cnt2 ? "Fennec" : "Snuke"));

	

	//printf("Time used = %.12f",(double)(clock())/CLOCKS_PER_SEC);

	return 0;

}