#include<vector>
#include<algorithm>
#include<queue>
#include<iostream>

#define rep(i,n) for(int i = 0; i < n; ++i)
#define reps(i,f,n) for(int i = f; i <= n; ++i)
#define eb emplace_back
#define all(x) x.begin(), x.end()

using namespace std;
using PII=pair<int,int>;
using PPI=pair<int,PII>;
using ll=long long;

const ll INF = 10000000000000LL;


template<typename T>
class ShortestPath{
  public:
    class Edge{
      public:
        T val;
        int to;
        Edge(T v, int t):val(v), to(t){}
    };

    int n;
    vector< vector<Edge> > g;
    vector<T> d;
    vector<T> p;
    vector<int> used;
    vector<int> u;
    vector<vector<T> > tmp;
    T INF;
    using PTI=pair<T,int>;


    ShortestPath(int _n, const T inf):n(_n),g(n),d(n),p(n), INF(inf), u(n){
    }

    void add_undi_edge(int from, int to, T cost){
      g[from].emplace_back(Edge(cost, to));
      g[to].emplace_back(Edge(cost, from));
    }

    void add_di_edge(int from, int to, T cost){
      g[from].emplace_back(Edge(cost, to));
    }

    void dijkstra(int s, int go){
      //verify GRL_1_A
      priority_queue<PTI, vector<PTI>, greater<PTI> > pq;
      used.resize(n, 0);
      rep(i,n){
        d[i] = INF;
        p[i] = -1;
      }
      d[s] = 0;
      pq.push(PTI(0, s));
      while(!pq.empty()){
        T val = pq.top().first;
        int current = pq.top().second;
        pq.pop();
        if(used[current])continue;
        used[current] = 1;
        if(current == go)break;
        rep(i, g[current].size()){
          Edge e = g[current][i];
          if( d[e.to] > d[current] + e.val){
            d[e.to] = d[current] + e.val;
            p[e.to] = current;
            pq.push(PTI(d[e.to], e.to));
          }
        }
      }
    }

    int nc(int cur, int ig1, int ig2){
      int cnt = 0;
      queue<int> q;
      q.push(cur);
      u[cur] = 1;
      if(ig1 != -1)u[ig1] = 1;
      if(ig2 != -1)u[ig2] = 1;
      cnt++;
//       cout << "cur " << cur << endl;

      while(!q.empty()){
        cur = q.front();q.pop();
        rep(i, g[cur].size()){
          Edge e = g[cur][i];
          if(u[e.to] == 1)continue;
          q.push(e.to);
          u[e.to] = 1;
          cnt++;
        }
      }
      if(ig1 != -1)u[ig1] = 0;
      if(ig2 != -1)u[ig2] = 0;
      return cnt;
    }
};


int main(void){
  int n;
  int a, b;

  cin >> n;
  ShortestPath<ll> sp(n, 1000000000);
  rep(i, n-1){
    cin >> a >> b;
    a--;b--;
    sp.add_undi_edge(a, b, 1LL);
  }
  sp.dijkstra(0, n-1);
  int current = n-1;
  vector<int> path;
  path.push_back(-1);
  while(current != 0){
    path.push_back(current);
//     cout << current << endl;
    current = sp.p[current];
  }
  path.push_back(current);
  path.push_back(-1);

  int index[2]={(int)path.size()-2, 1};
  int cnt[2] = {0};
  for(int i = 0; i < path.size(); ++i){
//     cout << index[0] << " " << index[1] << "(" << cnt[0] << " , " << cnt[1] << endl;
    if(index[0] == index[1]){
      cnt[0] += sp.nc(path[index[0]], path[index[0]-1], path[index[0]+1]);
      break;
    }else{
      rep(j, 2){
        cnt[j] += sp.nc(path[index[j]], path[index[j]-1], path[index[j]+1]);
      }
    }
    index[1]++;index[0]--;
    if(index[0] < index[1])break;
  }
//   cout << cnt[0] << " vs " << cnt[1] << endl;

  if(cnt[0] <= cnt[1]){
    cout << "Snuke" << endl;
  }else{
    cout << "Fennec" << endl;
  }

  return 0;
}


Measured memory_bytes: 10364