// Original C++ solution (slower):


#include <iostream>

#include <cstdio>

#include <algorithm>

#include <iomanip>

#include <cmath>

#include <vector>

#include <queue>

#include <map>

#include <set>

#include <time.h>



#define rep(num)      for (long long _ = 0; _ < num; _++)

#define loop(i, num)  for (long long i = 0; i < num; i++)



using namespace std;



int n;



vector<bool> vis;



vector<vector<int>> nei, dis;



void dfs(int from, int len, int mem) {

    

    vis[from] = 1;

    

    dis[mem][from] = len;

    

    loop (i, nei[from].size()) {

        

        if (!vis[nei[from][i]]) {

            

            dfs(nei[from][i], len + 1, mem);

            

        }

        

    }

    

}



int main() {

    

    cin >> n;

    

    nei.resize(n + 1);

    

    vis.resize(n + 1);

    

    dis.resize(2, vector<int>(n + 1, 1e9));

    

    loop (i, n - 1) {

        

        int p1, p2;

        

        cin >> p1 >> p2;

        

        nei[p1].push_back(p2);

        

        nei[p2].push_back(p1);

        

    }

    

    dfs(1, 0, 0);

    

    loop (i, n + 1) {

        

        vis[i] = 0;

        

    }

    

    dfs(n, 0, 1);

    

    int f = 0, s = 0;

    

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

        

        if (dis[0][i] > dis[1][i]) {

            

            ++s;

            

        } else {

            

            ++f;

            

        }

        

    }

    

    if (s >= f) {

        

        cout << "Snuke" << endl;

        

    } else {

        

        cout << "Fennec" << endl;

        

    }

    

}


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

#include <cstring>

using namespace std;



int first[100003], next[200003], node[200003], n, len, ans[3], m;

char fs[100003];

bool vis[100003];



inline void readin(int n)

{

    int p = 1;

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

    {

        int u, v;

        scanf("%d%d", &u, &v);

        next[p] = first[u];

        first[u] = p;

        node[p] = v;

        ++p;

        next[p] = first[v];

        first[v] = p;

        node[p] = u;

        ++p;

    }

}



bool dfs(int x, int deep)

{

    vis[x] = true;

    if (x == n)

    {

        len = deep >> 1;

        fs[n] = 2;

        ++ans[2];

        return true;

    }

    int t = first[x];

    while (t)

    {

        if (!vis[node[t]])

        {

            if (dfs(node[t], deep + 1))

            {

                if (deep > len)

                {

                    fs[x] = 2;

                    ++ans[2];

                }

                else

                {

                    fs[x] = 1;

                    ++ans[1];

                }

                return true;

            }

        }

        t = next[t];

    }

    return false;

}



void ddfs(int x)

{

    int t = first[x];

    while (t)

    {

        if (fs[node[t]] == 0)

        {

            ++ans[m];

            fs[node[t]] = m;

            ddfs(node[t]);

        }

        t = next[t];

    }

}



void init()

{

    memset(first, 0, sizeof first);

    memset(ans, 0, sizeof ans);

    memset(fs, 0, sizeof fs);

    memset(vis, false, sizeof vis);

}



int main()

{

    while (scanf("%d", &n) != EOF)

    {

        readin(n);

        dfs(1, 0);

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

        {

            if (fs[i])

            {

                m = fs[i];

                ddfs(i);

            }

        }

        printf("%s\n", ans[1] > ans[2] ? "Fennec" : "Snuke");

        init();

    }

}

// Fastest known solution for this problem: