#include <bits/stdc++.h>
using ll = long long;
// #define int ll
#define FOR(i, a, b) for (int i = (a); i < int(b); ++i)
#define RFOR(i, a, b) for (int i = (b)-1; i >= int(a); --i)
#define rep(i, n) FOR(i, 0, n)
#define rep1(i, n) FOR(i, 1, int(n) + 1)
#define rrep(i, n) RFOR(i, 0, n)
#define rrep1(i, n) RFOR(i, 1, int(n) + 1)
#define all(c) begin(c), end(c)
// const int MOD = 1000000007;

template <typename T>
void __print__(std::ostream &os, const char *, const char *tail, const T &fst) {
    os << fst << tail;
}
template <typename Fst, typename... Rst>
void __print__(std::ostream &os, const char *del, const char *tail, const Fst &fst,
               const Rst &... rst) {
    os << fst << del;
    __print__(os, del, tail, rst...);
}

#ifdef LOCAL
#define dump(...)                                         \
    do {                                                  \
        std::ostringstream os;                            \
        os << __LINE__ << ":\t" << #__VA_ARGS__ << " = "; \
        __print__(os, ", ", "\n", __VA_ARGS__);           \
        std::cerr << os.str();                            \
    } while (0)
#else
#define dump(...)
#endif

template <typename Fst, typename... Rst>
void println(const Fst &fst, const Rst &... rst) {
    __print__(std::cout, "\n", "\n", fst, rst...);
}
template <typename Fst, typename... Rst>
void print(const Fst &fst, const Rst &... rst) {
    __print__(std::cout, " ", "\n", fst, rst...);
}

template <typename iter>
void println_(iter bgn, iter end) {
    while (bgn != end) println(*bgn++);
}

template <typename iter>
void print_(iter bgn, iter end) {
    while (bgn != end) {
        std::cout << *bgn++;
        std::cout << (bgn == end ? "\n" : " ");
    }
}

int _ = (std::cout.precision(10), std::cout.setf(std::ios::fixed), std::cin.tie(0),
         std::ios::sync_with_stdio(0), 0);

template <typename T>
std::vector<T> ndarray(int n, T v) {
    return std::vector<T>(n, v);
}
template <typename... Args>
auto ndarray(int n, Args... args) {
    auto val = ndarray(args...);
    return std::vector<decltype(val)>(n, move(val));
}

template <typename T>
bool umax(T &a, const T &b) {
    return a < b ? a = b, true : false;
}

template <typename T>
bool umin(T &a, const T &b) {
    return a > b ? a = b, true : false;
}

using namespace std;

int n;
vector<vector<int>> g;

// void make_dist(int v, int p, int cur, vector<int> &d) {
//     d[v] = cur;
//     for (auto &w : g[v]) {
//         if (w == p) continue;
//         make_dist(w, v, cur + 1, d);
//     }
// }

bool make_path(int v, int p, int d, vector<int> &path) {
    if (v == d) {
        path.push_back(v);
        return true;
    }
    for (auto &w : g[v]) {
        if (w == p) continue;
        if (make_path(w, v, d, path)) {
            path.push_back(v);
            return true;
        }
    }
    return false;
}

int count(int v, int p, int bad) {
    int res = 1;
    for (auto &w : g[v]) {
        if (w == p || w == bad) continue;
        res += count(w, v, bad);
    }
    return res;
}

int main() {
    while (cin >> n) {
        g.assign(n, {});
        rep(i, n- 1){
            int a, b;
            cin >> a >> b;
            --a; --b;
            g[a].push_back(b);
            g[b].push_back(a);
        }
        vector<int> path;
        make_path(0, -1, n-1, path);
        reverse(all(path));
        //print_(all(path));
        int a, b;
        if (path.size()%2 == 1) {
            int m = path.size() / 2;
            a = count(0, -1, path[m+1]);
            b = n - a;
        } else {
            int m = path.size() / 2;
            a = count(0, -1, path[m]);
            b = n - a;
        }
        if (a > b) {
            print("Fennec");
        } else {
            print("Snuke");
        }
        // vector<int> dist1(n, -1);
        // vector<int> dist2(n, -1);
        // make_dist(0, -1, 0, dist1);
        // make_dist(n-1, -1, 0, dist2);
        // // print_(all(dist1));
        // // print_(all(dist2));
        // int a = 0, b = 0;
        // rep(i, n) {
        //     if (dist1[i] < dist2[i]) {
        //         ++a;
        //     } else {
        //         ++b;
        //     }
        // }
        // dump(a, b);
        // if (a >= b) {
        //     print("Fennec");
        // } else {
        //     print("Snuke");
        // }
    }
}


Measured memory_bytes: 12668