#include <bits/stdc++.h>
#define ll long long
using namespace std;

ll gcd(ll a, ll b){
    if(b == 0) return a;
    else return gcd(b, a%b);
}

ll power(ll  a, ll b){
   ll  ans = 1;
   while(b){
      if(b&1){
         ans *= a;
      }
      a *= a;
      b /= 2;
   }
   return ans;
}

int maxPoints(vector<int> &A, vector<int> &B) {
    // Do not write main() function.
    // Do not read input, instead use the arguments to the function.
    // Do not print the output, instead return values as specified

    int N = A.size();
    if(N <= 2) return N;
    int maxPoint = 0;
    int curMax, overlapPoints, verticalPoints;

    map < pair<int, int>, int> slopeMap;

    vector <pair <int,int> > points;
    for(int i = 0; i < N; i++){
        points.push_back({A[i], B[i]});
    }

    for (int i = 0; i < N; i++)
    {
        curMax = overlapPoints = verticalPoints = 0;


        for (int j = i + 1; j < A.size(); j++)
        {
            if (points[i] == points[j])
                overlapPoints++;

            else if (points[i].first == points[j].first)
                verticalPoints++;

            else
            {
                int yDif = points[j].second - points[i].second;
                int xDif = points[j].first - points[i].first;
                int g = gcd(xDif, yDif);
                yDif /= g;
                xDif /= g;

                // increasing the frequency of current slope
                // in map
                slopeMap[make_pair(yDif, xDif)]++;
                curMax = max(curMax, slopeMap[make_pair(yDif, xDif)]);
            }

            curMax = max(curMax, verticalPoints);
        }

        // updating global maximum by current point's maximum
        maxPoint = max(maxPoint, curMax + overlapPoints + 1);

        // printf("maximum colinear point which contains current
        // point are : %d\n", curMax + overlapPoints + 1);
        slopeMap.clear();
    }
    return maxPoint;

}

ll arr[234561], b[12345], level[223456], vis[223456], parent[213456];

int s = 0;

void bfs(int n, vector <vector<int> > &vec){
     queue <int> q;
     q.push(n);
     level[n] = 0;
     vis[n] = 1;
     while(!q.empty()){
           int p = q.front();
           q.pop();
           for(int i = 0; i < vec[p].size(); i++){
               if(!vis[vec[p][i]]){
                  level[vec[p][i]] = level[p]+1;
                  parent[vec[p][i]] = p;
                  q.push(vec[p][i]);
                  vis[vec[p][i]] = 1;
               }
           }
     }
}

void dfs(int n, vector <vector<int> > &vec){
     if(n == 1) return;
     vis[n] = vec.size()-1;
     if(n != vec.size()-1 && n != 1) s++;

     for(int i = 0; i < vec[n].size(); i++){
         if(vis[vec[n][i]] != vec.size()-1 && vis[vec[n][i]] != -1){
            dfs(vec[n][i], vec);
         }
     }
}

ll mod = 1e9+7;


int main()
{
 int n;
 cin >> n;
 vector <vector<int> > vec;
 vec.resize(n+1);
 for(int i = 0; i < n-1; i++){
     int u, v;
     cin >> u >> v;
     vec[u].push_back(v);
     vec[v].push_back(u);
 }
 bfs(1, vec);
 int f = 0;

 int p1 = parent[n];
 vis[1] = -1;
 while(p1 != 1){
       if(abs(level[p1]- level[1]) <= abs(level[p1] - level[n])) vis[p1] = -1;
       p1 = parent[p1];
 }

 dfs(n, vec);
 //cout << s << endl;
 f = n-2 - s;
 if(f > s) cout << "Fennec";
 else cout << "Snuke";
 return 0;
}



Measured memory_bytes: 13312