// Original C++ solution (slower):
#include <iostream>

#include <stdio.h>

#include <algorithm>

#include <string>

#include <cmath>

#include <vector>

#include <functional>

#include <stack>

#include <utility>

#include <map>

#include <queue>

#include <set>

#include <array>

#include <climits>

#include <cassert>



using namespace std;



typedef long long ll;

typedef pair<int, int> P;



const ll MOD = 1000000000 + 7;

const ll INF = LLONG_MAX;

const ll MAX_V = ll(1e5) + 5;

const double EPS = 10e-8;

const double PI = 3.14159265359;



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



int n, color[100005]{};

vector<int> G[100005], path;



bool dfs(int from, int to) {

    if (to == n - 1) {

        path.push_back(n - 1);

        return true;

    }

    if (G[to].size() == 1) return false;



    for (int i = 0; i < G[to].size(); i++) {

        if (G[to][i] == from) continue;

        if (dfs(to, G[to][i])) {

            path.push_back(to);

            return true;

        }

    }

    return false;

}



void paint(int from, int to) {

    if (color[to]!=0 && color[to] != color[from]) return;

    color[to] = color[from];

    for (int i = 0; i < G[to].size(); i++) {

        if (G[to][i] == from) continue;

        paint(to, G[to][i]);

    }

}



int main() {

    cin >> n;

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

        int a, b;

        cin >> a >> b;

        a--;

        b--;

        G[a].push_back(b);

        G[b].push_back(a);

    }



    for (int i = 0; i < G[0].size(); i++) {

        if (dfs(0, G[0][i])) break;

    }

    path.push_back(0);

    reverse(path.begin(), path.end());

    

    for (int i = 0; i < path.size(); i++) {

        int c;

        if (i < (path.size() + 1) / 2)

            c = 1;

        else

            c = 2;

        color[path[i]] = c;

    }

    paint(0, 0);

    paint(n - 1, n - 1);

    int cnt = 0;

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

        if (color[i] == 1) cnt++;

    }

    if (cnt * 2 > n)

        cout << "Fennec" << endl;

    else

        cout << "Snuke" << endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef pair<int, int> P;

const int MAX_N = int(1e5 + 5);

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



int n, d[2][MAX_N];

vector<vector<int> > G;



void bfs(int k){

    queue<P> que;

    int s = (k?n-1:0);

    que.push({s,0});

    while(!que.empty()){

        P p = que.front();

        que.pop();

        int v = p.first;

        if(d[k][v]!=-1)continue;

        d[k][v] = p.second;

        for(auto u : G[v]){

            if(d[k][u]!=-1)continue;

            que.push({u,p.second+1});

        }

    }

}



int main() {

    cin >> n;

    G.resize(n);

    REP(i,n-1){

        int a, b;

        cin >> a >> b;

        a--, b--;

        G[a].push_back(b);

        G[b].push_back(a);

    }

    REP(i,2) fill(d[i],d[i]+n,-1);

    REP(i,2) bfs(i); // 各頂点とFennec,Snukeの距離を求める

    int cnt = 0; // Fennecのとれる数

    REP(i,n){

        if(d[0][i]<=d[1][i])cnt++; // Fennecに近い

    }

    cout << (cnt > n/2 ? "Fennec":"Snuke") << endl; // とれる個数が過半数なら勝ち

    return 0;

}


// Fastest known solution for this problem: