#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>

#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif

// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>

#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;

typedef long long ll;
//typedef pair<int,int> Pint;
typedef pair<ll, ll> P;
//typedef pair<int, pair<int, int>> P;
//typedef tuple<int,int,int> T;
typedef vector<ll> vec;
typedef vector<vec> mat;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define revrep(i, n) for(ll i = n-1; i >= 0; i--)
ll max(ll a, ll b){return (a > b) ? a : b;}
ll min(ll a, ll b){return (a < b) ? a : b;}

ll INFL = 1000000000000000010;//10^18 = 2^60
int INF = 1000000000;//10^9
ll MOD  = 1000000007;
//vector<int> dy = {0,0,1,-1};
//vector<int> dx = {1,-1,0,0};

ll N;
vector<ll> edge[100010];

ll t[100010];//辺１からの距離
bool visited[100010];
bool paste[100010];
int color[100010];

void dfs(ll now){
  visited[now] = 1;
  for(int i = 0; i < edge[now].size(); i++){
    ll next = edge[now][i];
    if(visited[next] == 1) continue;
    t[next] = t[now] + 1;
    dfs(next);
  }
}

void nul(ll now){
  paste[now] = 1;
  for(int i = 0; i < edge[now].size(); i++){
    ll next = edge[now][i];
    if(paste[next] == 1) continue;
    if(color[next] != 0) continue;
    color[next] = color[now];
    nul(next);
  }
}

int main(){
  cin >> N;
  rep(i, N-1){
    ll a, b;
    cin >> a >> b;
    a--, b--;
    edge[a].push_back(b);
    edge[b].push_back(a);
  }
  memset(visited, INF, sizeof(visited));
  t[0] = 0;
  dfs(0);
  vector<ll> path;
  ll k = t[N-1];
  ll now = N-1;
  while(k > 0){
    path.push_back(now);
    rep(i, edge[now].size()){
      if(t[edge[now][i]] == k-1){
        now = edge[now][i];
        k--;
        break;
      }
    }
  }
  path.push_back(0);
  reverse(path.begin(), path.end());
  int s = 0, t = path.size() - 1;
  while(true){
    if(s > t) break;
    if(color[path[s]] != 0) break;
    color[path[s]] = 1;
    s++;
    if(color[path[t]] != 0) break;
    color[path[t]] = -1;
    t--;
  }
  for(ll x : path){
      if(paste[x] != 0) continue;
      nul(x);
  }
  
  ll cntF = 0, cntS = 0;
  rep(i, N){
    if(color[i] == 1) cntF++;
    else cntS++;
  }
  if(cntF > cntS){
    cout << "Fennec" << endl;
  }else{
    cout << "Snuke" << endl;
  }
}


Measured memory_bytes: 12788