// clang-format off
#include <bits/stdc++.h>
#define int long long
#define main signed main()
#define loop(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) loop(i, 0, n)
#define forever while(true)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define prec(n) fixed << setprecision(n)
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
using pii   = std::pair<int, int>;
using vi    = std::vector<int>;
using vd    = std::vector<double>;
using vc    = std::vector<char>;
using vb    = std::vector<bool>;
using vs    = std::vector<std::string>;
using vpii  = std::vector<pii>;
using vvi   = std::vector<vi>;
using vvb   = std::vector<vb>;
using vvpii = std::vector<vpii>;
template<typename A> using fn = std::function<A>;
constexpr int INF   = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
constexpr int MOD   = 1000000007;
constexpr double PI = acos(-1);
template<typename A, typename B> bool cmin(A &a, const B &b) { return a > b ? (a = b, true) : false; }
template<typename A, typename B> bool cmax(A &a, const B &b) { return a < b ? (a = b, true) : false; }
using namespace std;
// clang-format on

using Weight = int;
struct Edge {
  int src, dst;
  Weight weight;
  Edge(const int &s = 0, const int &d = 0, const Weight &w = 0)
    : src(s), dst(d), weight(w) {
  }
};

using Edges  = std::vector<Edge>;
using Array  = std::vector<Weight>;
using Matrix = std::vector<Array>;

class Graph {
  std::vector<Edges> g;

public:
  // clang-format off
  Graph(const int &size = 0) : g(size) { }

  void addArc(const int &src, const int &dst, const Weight &w = 1) {
    g[src].emplace_back(src, dst, w);
  }

  void addEdge(const int &node1, const int &node2, const Weight &w = 1) {
    addArc(node1, node2, w);
    addArc(node2, node1, w);
  }

  const Edges &operator[](const int &i) const { return g[i]; }

  Graph toRootedTree(int r);
  std::pair<std::vector<Weight>, std::vector<int>> dijkstra(const int &src, const int &inf);
  Matrix warshallFloyd(const int &inf);
  std::pair<Weight, Edges> prim(const int &r);
  template<typename UnionFind> std::pair<Weight, Edges> kruskal();
  Weight solveTSP(const int &inf);
  // clang-format on
};

std::pair<std::vector<Weight>, std::vector<int>> Graph::dijkstra(const int &src, const int &inf = std::numeric_limits<Weight>::max() / 8) {
  using state = std::pair<Weight, int>;
  std::priority_queue<state, std::vector<state>, std::greater<state>> q;
  std::vector<Weight> dist(g.size(), inf);
  std::vector<int> via(g.size());
  dist[src] = 0;
  q.emplace(0, src);
  while (q.size()) {
    Weight d;
    int v;
    std::tie(d, v) = q.top();
    q.pop();
    if (dist[v] < d) continue;
    for (auto &e : g[v]) {
      if (cmin(dist[e.dst], dist[v] + e.weight)) {
        via[e.dst] = v;
        q.emplace(dist[e.dst], e.dst);
      }
    }
  }
  return make_pair(dist, via);
}

main {
  int n;
  cin >> n;
  Graph g(n);
  rep(_, n - 1) {
    int a, b;
    cin >> a >> b;
    g.addEdge(--a, --b);
  }
  set<int> pset;
  {
    vi via = g.dijkstra(0).se;
    for (int i = via[n - 1]; i; i = via[i]) pset.insert(i);
  }
  vi state(n);
  priority_queue<pair<int, int>> bq, wq;
  bq.emplace(0, 0);
  wq.emplace(0, n - 1);
  for (;;) {
    for (int i = 0; i < 1;) {
      if (bq.size() == 0) {
        cout << "Snuke" << endl;
        return 0;
      }
      int p = bq.top().se;
      bq.pop();
      if (state[p]) continue;
      state[p] = 1;
      for (auto &e : g[p]) bq.emplace(pset.count(e.dst), e.dst);
      i++;
    }
    for (int i = 0; i < 1;) {
      if (wq.size() == 0) {
        cout << "Fennec" << endl;
        return 0;
      }
      int p = wq.top().se;
      wq.pop();
      if (state[p]) continue;
      state[p] = 1;
      for (auto &e : g[p]) wq.emplace(pset.count(e.dst), e.dst);
      i++;
    }
  }
}


Measured memory_bytes: 14288