using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Text;
using static System.Math;
using static System.Array;

namespace AtCoderSolve
{
    class Solve
    {
        const int mod = 1000000007;
        const int INF = int.MaxValue / 2;
        const long SINF = long.MaxValue / 2;

        static int N;
        static List<List<int>> G = new List<List<int>>();
        static bool[] seen;
        
        //static char[] s;
        static void Main(string[] args)
        {
            //var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            //Console.SetOut(sw);
            var cin = new Scanner();

            N = int.Parse(Console.ReadLine());
            seen = new bool[N];
            for(var i = 0; i < N; i++)
            {
                G.Add(new List<int>());
            }
            for(var i = 0; i < N - 1; i++)
            {
                var p = cin.SplitReader();
                int a = p[0] - 1;
                int b = p[1] - 1;
                G[a].Add(b);
                G[b].Add(a);
            }

            int[] dis1 = new int[N];
            int[] disN = new int[N];
            for(var i = 0; i < N; i++)
            {
                dis1[i] = i == 0 ? 0 : INF;
                disN[i] = i == N - 1 ? 0 : INF;
            }
            Dfs(0, dis1);
            for(var i = 0; i < N; i++)
            {
                seen[i] = false;
            }
            Dfs(N - 1, disN);

            int snuke = 0;
            int fennec = 0;
            for (var i = 1; i < N - 1; i++) 
            {
                if (dis1[i] <= disN[i])
                {
                    fennec++;
                }
                else
                {
                    snuke++;
                }
            }

            Console.WriteLine(fennec > snuke ? "Fennec" : "Snuke");
            

            //Console.Out.Flush();
        }

        static public void Dfs(int v,int[] d)
        {
            seen[v] = true;
            foreach(var next in G[v])
            {
                d[next] = Min(d[next], d[v] + 1);
                if (seen[next]) { continue; }
                Dfs(next, d);
            }
            
        }

    }

    public class Scanner
    {
        public int[] SplitReader()
        {
            int[] array = Console.ReadLine().Split().Select(int.Parse).ToArray();
            return array;
        }
        public long[] SplitReaderL()
        {
            long[] array = Console.ReadLine().Split().Select(long.Parse).ToArray();
            return array;
        }
    }

    public class UnionFind
    {
        public int[] parent;
        public int[] rank;
        public int[] size;
        public UnionFind(int n)
        {
            parent = new int[n];
            rank = new int[n];
            size = new int[n];
            for (var i = 0; i < n; i++)
            {
                parent[i] = i;
                rank[i] = 0;
                size[i] = 1;
            }
        }

        private int Root(int x)
        {
            return parent[x] == x ? x : parent[x] = Root(parent[x]);
        }

        public bool SameRoot(int x, int y)
        {
            return Root(x) == Root(y);
        }

        public void Unite(int x, int y)
        {
            x = Root(x);
            y = Root(y);
            if (x == y) { return; }

            if (rank[x] < rank[y])
            {
                parent[x] = y;
                size[y] += size[x];
                size[x] = 0;
            }
            else
            {
                parent[y] = x;
                if (rank[x] == rank[y]) { rank[x]++; }
                size[x] += size[y];
                size[y] = 0;
            }
        }

        public int GetSize(int x)
        {
            return size[Root(x)];
        }

    }



}






Measured memory_bytes: 41724