// Slower C++ solution:
#include<bits/stdc++.h>

#include<iostream>

#include<string>

#include<cmath>

#include<cstdio>

#include<cctype>

#include<cstring>

#include<iomanip>

#include<cstdlib>

#include<ctime>

#include<set>

#include<map>

#include<utility>

#include<queue>

#include<vector>

#include<stack>

#include<sstream>

#include<algorithm>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

typedef pair<ll,ll> pii;

typedef vector<pii> vii;

typedef vector<ll> vi;

typedef queue<ll> qi;

typedef queue<char> qc;

typedef queue<string> qs;

typedef vector<char> vc;

typedef vector<string> vs;

typedef map<char,ll> mpci;

typedef map<ll,ll> mpii;

typedef map<string,ll> mpsi;

typedef set<ll> sei;

typedef set<char> sec;

typedef set<string> ses;

typedef stack<ll> si;

typedef stack<char> sc;

typedef vector<ll> vll;

typedef vector<vi> vvi;

typedef vector<double> vd;

typedef pair<ll,ll> pll;

typedef pair<double,double> pdd;

typedef vector<pll> vpll;

typedef vector<pdd> vdd;

typedef unsigned int uint;

typedef long double ld;

typedef vector<bool> vb;

typedef vector<double> vd;

typedef vector<vi> vvi;

typedef vector<vvi> vvvi;

typedef vector<vii> vvii;

/*=====================================================================*/

#define mp make_pair

#define pb push_back

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

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

#define len(a) (int)(a.length())

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

#define fi first

#define se second

#define be begin

#define en end

#define repd(i,n) for(int i=n-1;i>=0;i--)

#define forn(i,p,n) for(int i=p;i<n;i++)

#define ford(i,p,n) for(int i=n-1;i>=p;i--)

#define foreach(i,c) for(__typeof(c.begin())i=(c.begin());i!=(c).end();++i)

#define zero(a) memset(a,0,sizeof(a))

#define number(a,num) memeset(a,num,sizeof(a))



/*=====================================================================*/



inline void read(int &x)

{

	short negative=1;

    x=0;

    char c=getchar();

    while(c<'0' || c>'9')

    {

		if(c=='-')

			negative=-1;

		c=getchar();

	}

    while(c>='0' && c<='9')

        x=(x<<3)+(x<<1)+(c^48),c=getchar();

    x*=negative;

}

inline void write(long long x) {

  static long long sta[35];

  long long top = 0;

  do {

    sta[top++] = x % 10, x /= 10;

  } while (x);

  while (top) putchar(sta[--top] + 48);

  puts("");

}

/*======================================================================*/

bool prime(int n)

{

	if(n==0||n==1)

	  return false;

	for(int i=2;i*i<=n;i++)

	  if(n%i==0)

	    return false;

	return true;

}

/*======================================================================*/

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

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

const int maxn=1<<18;

int n;

vi e[maxn];

int cnt[maxn];

vi vct;

int frst;

/*======================================================================*/

void dfs(int v,int  pr)

{

	cnt[v]=1;

	vct.pb(v);

	if(v==n-1)

	{

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

	}

	rep(i,e[v].size())

	{

		int to=e[v][i];

		if(to==pr)

		  continue;

		dfs(to,v);

		cnt[v]+=cnt[to];

	}

	vct.pop_back();

}

int main()

{

  /*

	ios_base::sync_with_stdio(0);

	cin(tie);

	freopen("input.txt","r",stdin);

	freopen("output.txt","w",stdout);

  */

  /*====================================================================*/

  read(n);

  rep(i,n-1)

  {

  	int a,b;

  	read(a);

  	read(b);

  	a--,b--;

  	e[a].pb(b);

  	e[b].pb(a);

  }

  frst=-1;

  dfs(0,0);

  if(cnt[frst]*2<n)

    cout<<"Fennec";

  else

    cout<<"Snuke";

  return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.3285362911605327x):
// È¥°É£¡Æ¤¿¨Çð! °Ñ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;

vector<int> v[100010];

int mid=-1;

vector<int> MainRoad;

int cnt[100010];



void DFS(int x,int pre)

{

	cnt[x]=1;

	MainRoad.pb(x);

	

	if(x==n-1)mid=MainRoad[((int)MainRoad.size()+1)/2];

	

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

	{

		int to=v[x][i];

		

		if(to==pre)continue;

		else

		{

			DFS(to,x);

			

			cnt[x]+=cnt[to];

		}

	}

	

	MainRoad.pop_back();

}



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

{

	ios::sync_with_stdio(false);

	

	cin>>n;

	

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

	{

		int x,y;

		cin>>x>>y;

		

		x--,y--;

		

		v[x].pb(y);

		v[y].pb(x);

	}

	

	DFS(0,0);

	

	cout<<(cnt[mid]*2<n ? "Fennec" : "Snuke");

	

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

	return 0;

}