#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <unordered_set>
#include <stack>
#include <queue>
#include <math.h>
#include <string>
#include <numeric>
#include <algorithm>
#include <utility>

using namespace std;
typedef long long ll;
typedef unsigned long long ull;


int gcd(int a, int b) {
    while (b != 0) {
        auto na = a % b;
        a = b;
        b = na;
    }
    return a;
}



class DisjointSetUnion {
public:
    explicit DisjointSetUnion(int pointsCount);
    int find(int point);
    bool unite(int left, int right);
    int addPoint();
    int components() { return components_; }

    std::vector<int> roots_;
    std::vector<int> size_;
    // use same stack for all calls of find method
    std::stack<int> nodes_;
    int components_;
};

DisjointSetUnion::DisjointSetUnion(int pointsCount) {
    roots_.resize(pointsCount);
    size_.assign(pointsCount, 1);
    components_ = pointsCount;
    for (int element = 0; element < pointsCount; ++element) {
        roots_[element] = element;
    }
}

int DisjointSetUnion::find(int point) {
    auto current = point;
    while (roots_[current] != current) {
        nodes_.push(current);
        current = roots_[current];
    }
    while (!nodes_.empty()) {
        roots_[nodes_.top()] = current;
        nodes_.pop();
    }
    return current;
}

bool DisjointSetUnion::unite(int left, int right) {
    left = find(left);
    right = find(right);
    if (left == right) {
        return false;
    }
    if (size_[left] < size_[right]) {
        std::swap(left, right);
    }
    roots_[right] = left;
    --components_;
    size_[left] += size_[right];
    return true;

}

int DisjointSetUnion::addPoint() {
    roots_.push_back(roots_.size());
    size_.push_back(1);
    ++components_;
    return roots_.size();
}


void oneCase() {
    int n;
    cin >> n;
    vector<set<int>> edges(n);
    for (int i = 1; i < n; ++i) {
        int a,b;
        cin >> a >> b;
        --a;
        --b;
        edges[a].insert(b);
        edges[b].insert(a);
    }
    queue<int> nodes;
    nodes.emplace(n - 1);
    vector<int> parent(n, -1);
    vector<int> path;
    while (!nodes.empty()) {
        auto cur = nodes.front();
        nodes.pop();
        if (cur == 0) {
            break;
        }
        for (auto out : edges[cur]) {
            if (out == parent[cur]) {
                continue;
            }
            if (parent[out] == -1) {
                parent[out] = cur;
                nodes.emplace(out);
            }
        }
    }
    auto cur = 0;
    while (cur != -1) {
        path.push_back(cur);
        cur = parent[cur];
    }
    auto l = path.size();
    auto f = (l - 1) / 2;
    int A = 0, B = 0;

    edges[path[f]].erase(path[f + 1]);
    edges[path[f + 1]].erase(path[f]);

    DisjointSetUnion dsu(n);
    for (int i  = 0; i < n; ++i) {
        for (auto el : edges[i]) {
            dsu.unite(i, el);
        }
    }


    A = dsu.size_[dsu.find(0)];
    B = dsu.size_[dsu.find(n - 1)];

    if (A > B) {
        cout << "Fennec" << "\n";
    } else {
        cout << "Snuke" << "\n";
    }
}


int main() {
    int t = 1;
//    cin >> t;
    while (t--) {
       oneCase();
    }

    return 0;
}

ll fact(ll n, ll mod) {
    ll res = 1;
    while (n > 0) {
        res = (res * n) % mod;
        --n;
    }
    return res;
}


Measured memory_bytes: 15996