#include <bits/stdc++.h>
#define rep(n) for(int I = 0; (I) < (n); ++(I) )
#define repeat(i, n) for( int i = 0; (i) < (n); ++(i) )
#define repeat_to(i, n) for( int i = 0; (i) <= (n); ++(i) )
#define repeat_from(i, m, n) for( int i = (m); (i) < (n); ++(i) )
#define repeat_from_to(i, m, n) for( int i = (m); (i) <= (n); ++(i) )
#define el cout<<endl
#define dump(x) cout<<" "<<#x<<"="<<x
#define vdump(v) for(size_t I=0; I<v.size(); ++I){cout<<" "<<#v<<"["<<I<<"]="<<v[I];} cout<<endl
using namespace std;
using lint = long long;
using ld = long double;

/****************** グラフ ******************/
// 諸宣言
using Weight = lint;
using Flow = lint;
struct Edge {
    int src, dst;
    Weight weight;
    Flow cap;
    Edge() : src(0), dst(0), weight(0) {}
    Edge(int s, int d, Weight w) : src(s), dst(d), weight(w) {}
    Edge(int s, int d, Weight w, Flow c) : src(s), dst(d), weight(w), cap(c) {}
};
using Edges = vector<Edge>;
using Graph = vector<Edges>;
using Array = vector<Weight>;
using Matrix = vector<Array>;

void add_edge(Graph &g, int a, int b, Weight w = 1, Flow c = 1) {
    g[a].emplace_back(a, b, w, c);
    g[b].emplace_back(b, a, w, c);
}
void add_arc(Graph &g, int a, int b, Weight w = 1, Flow c = 1) {
    g[a].emplace_back(a, b, w, c);
}

// ダイクストラ法（プライオリティーキュー）O((E+V)logV)
std::vector<Weight> dijkstra(const Graph &g, int s) {
    const Weight INF = std::numeric_limits<Weight>::max() / 8;
    using state = std::tuple<Weight, int>;
    std::priority_queue<state> q;
    std::vector<Weight> dist(g.size(), INF);
    dist[s] = 0;
    q.emplace(0, s);
    while (q.size()) {
        Weight d;
        int v;
        std::tie(d, v) = q.top();
        q.pop();
        d *= -1;
        /* if(v == t) return d; */
        if (dist[v] < d) continue;
        for (auto &e : g[v]) {
            if (dist[e.dst] > dist[v] + e.weight) {
                dist[e.dst] = dist[v] + e.weight;
                q.emplace(-dist[e.dst], e.dst);
            }
        }
    }
    return dist;
}

int to_root (const Graph &g, const vector<Weight> &depth, int s) {
    if (s == 0) return 0;
    int d = depth[s];
    for(const auto &e: g[s]) {
        if (depth[e.dst] == d - 1)
            return e.dst;
    }
    return -1;
}

int connect_numbers (const Graph &g, int s) {
    int res = 0;
    vector<bool> used(g.size() - 1, false);
    queue<int> q;
    
    q.push(s);
    used[s] = true;
    ++res;
    
    while (!q.empty()) {
        int v = q.front();
        q.pop();
        for (const auto &e: g[v]) {
            if (!used[e.dst]) {
                used[e.dst] = true;
                ++res;
                q.push(e.dst);
            }
        }
    }
    return res;
}

int main(void) {
    int n; cin >> n;
    Graph g(n);
    rep(n-1) {
        int a, b; cin >> a >> b;
        --a; --b;
        add_edge(g, a, b);
    }
    
    vector<Weight> depth = dijkstra(g, 0);
    int p = n-1;
    int d = depth[p];
    
    while (true) {
        int np = to_root(g, depth, p);
        //dump(d); dump(p); dump(depth[p]); dump(np); dump(depth[np]); el;
        if (depth[np] == d / 2) {
            repeat(i, (int)g[np].size()) {
                if (g[np][i].dst == p) {
                    g[np].erase(g[np].begin() + i);
                }
            }
            repeat(i, (int)g[p].size()) {
                if (g[p][i].dst == np) {
                    g[p].erase(g[p].begin() + i);
                }
            }
            break;
        }
        p = np;
    }
    
    if (connect_numbers(g, 0) > connect_numbers(g, n-1)) {
        cout << "Fennec" << endl;
    }
    else {
        cout << "Snuke" << endl;
    }
    
    return 0;
}

Measured memory_bytes: 10112