// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



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

#define ALL(a) (a).begin(), (a).end()



template <class T> inline bool chmin(T &a, T b)

{

  if (a > b)

  {

    a = b;

    return true;

  }

  return false;

}

template <class T> inline bool chmax(T &a, T b)

{

  if (a < b)

  {

    a = b;

    return true;

  }

  return false;

}



using ll = long long;

using ld = long double;

using P = pair<int, int>;

using DoP = pair<double, double>;

using edge = struct{ int to; ll cost;};



const int di[] = {0, 1, 0, -1, 1, 1, -1, -1};

const int dj[] = {1, 0, -1, 0, 1, -1, 1, -1};

const int INF = 1e9 + 100;

const ll INF64 = 1ll<<40;

const int mod = 1000000007;



struct Sieve

{

  int n;

  vector<int> f, primes;

  Sieve(int n = 1) : n(n), f(n + 1)

  {

    f[0] = f[1] = -1;

    for (ll i = 2; i <= n; ++i)

    {

      if (f[i])

        continue;

      primes.push_back(i);

      f[i] = i;

      for (ll j = i * i; j <= n; j += i)

      {

        if (!f[j])

          f[j] = i;

      }

    }

  }

  bool isPrime(int x) { return f[x] == x; }

  vector<int> factorList(int x)

  {

    vector<int> res;

    while (x != 1)

    {

      res.push_back(f[x]);

      x /= f[x];

    }

    return res;

  }

  vector<P> factor(int x)

  {

    vector<int> fl = factorList(x);

    if (fl.size() == 0)

      return {};

    vector<P> res(1, P(fl[0], 0));

    for (int p : fl)

    {

      if (res.back().first == p)

      {

        res.back().second++;

      }

      else

      {

        res.emplace_back(p, 1);

      }

    }

    return res;

  }

};

struct UnionFind

{

  vector<int> par;

  UnionFind(int N) : par(N)

  {

    for (int i = 0; i < N; i++)

      par[i] = i;

  }

  int root(int x)

  {

    if (par[x] == x)

      return x;

    return par[x] = root(par[x]);

  }

  void unite(int x, int y)

  {

    int rx = root(x);

    int ry = root(y);

    if (rx == ry)

      return;

    par[rx] = ry;

  }

  bool same(int x, int y)

  {

    int rx = root(x);

    int ry = root(y);

    return rx == ry;

  }

};

struct mint

{

  ll x; // typedef long long ll;

  mint(ll x = 0) : x((x % mod + mod) % mod) {}

  mint operator-() const { return mint(-x); }

  mint &operator+=(const mint a)

  {

    if ((x += a.x) >= mod)

      x -= mod;

    return *this;

  }

  mint &operator-=(const mint a)

  {

    if ((x += mod - a.x) >= mod)

      x -= mod;

    return *this;

  }

  mint &operator*=(const mint a)

  {

    (x *= a.x) %= mod;

    return *this;

  }

  mint operator+(const mint a) const

  {

    mint res(*this);

    return res += a;

  }

  mint operator-(const mint a) const

  {

    mint res(*this);

    return res -= a;

  }

  mint operator*(const mint a) const

  {

    mint res(*this);

    return res *= a;

  }

  mint pow(ll t) const

  {

    if (!t)

      return 1;

    mint a = pow(t >> 1);

    a *= a;

    if (t & 1)

      a *= *this;

    return a;

  }



  // for prime mod

  mint inv() const

  {

    return pow(mod - 2);

  }

  mint &operator/=(const mint a)

  {

    return (*this) *= a.inv();

  }

  mint operator/(const mint a) const

  {

    mint res(*this);

    return res /= a;

  }

};

struct combination

{

  vector<mint> fact, ifact;

  combination(int n) : fact(n + 1), ifact(n + 1)

  {

    assert(n < mod);

    fact[0] = 1;

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

      fact[i] = fact[i - 1] * i;

    ifact[n] = fact[n].inv();

    for (int i = n; i >= 1; --i)

      ifact[i - 1] = ifact[i] * i;

  }

  mint operator()(int n, int k)

  {

    if (k < 0 || k > n)

      return 0;

    return fact[n] * ifact[k] * ifact[n - k];

  }

};



int n;

vector<vector<int>> E(100001);

vector<int> zd(100001), nd(100001);



void dfs(int now, int prev, int cost, int swit) {



  if(swit) zd[now] = cost;

  else nd[now] = cost;



  for(auto next : E[now]) {

    if(next == prev) continue;

    dfs(next, now, cost+1, swit);

  }



}

int main()

{

  cin >> n;

  rep(i, n-1) {

    int a, b;

    cin >> a >> b;

    E[a].push_back(b);

    E[b].push_back(a);

  }

  dfs(1, 0, 0, 1);

  dfs(n, 0, 0, 0);

  int s = 0, f = 0;

  rep(i, n) {

    if(zd[i+1] <= nd[i+1]) ++f;

    else ++s;

  }

  if(f > s) cout << "Fennec" << endl;

  else cout << "Snuke" << endl;

}

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

using namespace std;



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

#define ALL(a) (a).begin(), (a).end()

#define SZ(x) ((int)(x).size())



template <class T>inline bool chmin(T &a, const T b)

{

  if (a > b)

  {

    a = b;

    return true;

  }

  return false;

}

template <class T>inline bool chmax(T &a, const T b)

{

  if (a < b)

  {

    a = b;

    return true;

  }

  return false;

}



using ll = long long;

using ld = long double;

using P = pair<int, int>;

using llP = pair<ll, ll>;

using DoP = pair<double, double>;



const int di[] = {0, 1, 0, -1, 1, 1, -1, -1};

const int dj[] = {1, 0, -1, 0, 1, -1, 1, -1};

const int INF = 1 << 29;

const ll INF64 = 1ll << 45;

const int mod = 1000000007;



struct mint

{

  ll x; // typedef long long ll;

  mint(ll x = 0) : x((x % mod + mod) % mod) {}

  mint operator-() const { return mint(-x); }

  mint &operator+=(const mint a)

  {

    if ((x += a.x) >= mod)

      x -= mod;

    return *this;

  }

  mint &operator-=(const mint a)

  {

    if ((x += mod - a.x) >= mod)

      x -= mod;

    return *this;

  }

  mint &operator*=(const mint a)

  {

    (x *= a.x) %= mod;

    return *this;

  }

  mint operator+(const mint a) const

  {

    mint res(*this);

    return res += a;

  }

  mint operator-(const mint a) const

  {

    mint res(*this);

    return res -= a;

  }

  mint operator*(const mint a) const

  {

    mint res(*this);

    return res *= a;

  }

  mint pow(ll t) const

  {

    if (!t)

      return 1;

    mint a = pow(t >> 1);

    a *= a;

    if (t & 1)

      a *= *this;

    return a;

  }



  // for prime mod

  mint inv() const

  {

    return pow(mod - 2);

  }

  mint &operator/=(const mint a)

  {

    return (*this) *= a.inv();

  }

  mint operator/(const mint a) const

  {

    mint res(*this);

    return res /= a;

  }

};



// h(n, r) = c(n+r-1, r)

struct combination

{

  vector<mint> fact, ifact;

  combination(int n) : fact(n + 1), ifact(n + 1)

  {

    assert(n < mod);

    fact[0] = 1;

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

    fact[i] = fact[i - 1] * i;

    ifact[n] = fact[n].inv();

    for (int i = n; i >= 1; --i)

    ifact[i - 1] = ifact[i] * i;

  }

  mint operator()(int n, int k)

  {

    if (k < 0 || k > n)

    return 0;

    return fact[n] * ifact[k] * ifact[n - k];

  }

};



int main()

{

  int n;

  cin >> n;

  vector<vector<int>> e(n+1);

  rep(i, n-1) {

    int a, b;

    cin >> a >> b;

    e[a].push_back(b);

    e[b].push_back(a);

  }

  vector<int> fen(n+1, INF), sun(n+1, INF);

  fen[1] = 0;

  fen[n] = INF-1;

  sun[n] = 0;

  sun[1] = INF-1;

  queue<int> q;

  auto update = [&](int now, vector<int> &vec) {

    for(auto next : e[now]) {

      //cout << "now" << now << "next" << next << endl;

      if(vec[next] == INF) {

        vec[next] = vec[now]+1;

        q.push(next);

      }

    }

  };



  q.push(1);

  while(!q.empty()) {

    int now = q.front(); q.pop();

    update(now, fen);

  }

  q.push(n);

  while(!q.empty()) {

    int now = q.front(); q.pop();

    update(now, sun);

  }

  int f=0,s=0;

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

    if(fen[i] <= sun[i]) ++f;

    else ++s;

  }

  if(f > s) cout << "Fennec" << endl;

  else cout << "Snuke" << endl;

}

// Fastest known solution for this problem: