using System;
using System.Collections.Generic;
using System.Linq;

namespace x
{
    class Program
    {
        static void Main(string[] args)
        {
            var vCount = IOUtils.ReadInt();
            var edges = IOUtils.ReadIntLines(vCount - 1);

            // var dj = new Dijkstra(vCount, false);
            // foreach (var edge in edges)
            // {
            //     dj.AddEdge(edge[0], edge[1], 1);
            // }
            // dj.Calc(1, vCount);

            // //Fenの始点とSnkの始点を結ぶ道における点の取り分を決める
            // var route = dj.GetRoute(vCount);
            // var countFenCanGet = route.Count % 2 == 0 ? route.Count / 2 : route.Count / 2 + 1;
            // var fenNodes = new HashSet<int>(route.Take(countFenCanGet));
            // var snkNodes = new HashSet<int>(route.Skip(countFenCanGet));

            var graph = new AdjacencyListUndirectedGraph(vCount, edges);
            var finSteps = graph.EnumerateVertexesBFS(1);
            var snkSteps = graph.EnumerateVertexesBFS(vCount).ToDictionary(s => s.vertex);
            var finCnt = 0;
            var snkCnt = 0;
            var finWinCnt = vCount / 2 + 1;
            var snkWinCnt = vCount % 2 == 0 ? vCount / 2 : vCount / 2 + 1;
            foreach (var finStep in finSteps)
            {
                var snkStep = snkSteps[finStep.vertex];
                if (finStep.step <= snkStep.step) {
                    finCnt++;
                    if (finCnt >= finWinCnt) {
                        System.Console.WriteLine("Fennec");
                        return;
                    }
                } else {
                    snkCnt++;
                    if (snkCnt >= snkWinCnt) {
                        System.Console.WriteLine("Snuke");
                        return;
                    }
                }
            }
        }
    }

    struct VertexAndStep
    {
        public readonly int vertex;
        public readonly int step;

        public VertexAndStep(int v, int s)
        {
            this.vertex = v;
            this.step = s;
        }
    }

    /// <summary>
    /// 無方向グラフを隣接リストで扱う
    /// </summary>
    class AdjacencyListUndirectedGraph
    {
        class Node
        {
            public int V { get; }
            private HashSet<int> nexts = new HashSet<int>();

            public Node(int v)
            {
                this.V = v;
            }

            public bool HasNext(int v)
            {
                return this.nexts.Contains(v);
            }
            public bool AddNext(int v)
            {
                if (v == this.V) throw new ArgumentException();
                return this.nexts.Add(v);
            }
            public IReadOnlyCollection<int> AllNexts()
            {
                return this.nexts;
            }
            public bool RemoveNext(int v)
            {
                return this.nexts.Remove(v);
            }
        }

        private readonly IReadOnlyDictionary<int, Node> nodeDic;

        public int VertexCount { get; }

        public AdjacencyListUndirectedGraph(int vertexCount, IEnumerable<Tuple<int, int>> edges)
        {
            if (vertexCount < 0) throw new ArgumentOutOfRangeException(nameof(vertexCount));
            this.VertexCount = vertexCount;

            this.nodeDic = Enumerable.Range(1, vertexCount).ToDictionary(v => v, v => new Node(v));

            foreach (var edge in edges)
            {
                this.AddEdge(edge.Item1, edge.Item2);
            }
        }
        public AdjacencyListUndirectedGraph(int vertexCount, IEnumerable<int[]> edges)
        {
            if (vertexCount < 0) throw new ArgumentOutOfRangeException(nameof(vertexCount));
            this.VertexCount = vertexCount;

            this.nodeDic = Enumerable.Range(1, vertexCount).ToDictionary(v => v, v => new Node(v));

            foreach (var edge in edges)
            {
                if (edge.Length != 2) throw new ArgumentException("invalid edge length " + edge.Length);
                this.AddEdge(edge[0], edge[1]);
            }
        }

        public bool AddEdge(int v1, int v2)
        {
            if (!this.nodeDic[v1].AddNext(v2)) return false;
            if (!this.nodeDic[v2].AddNext(v1))
            {
                throw new InvalidProgramException("invalid state " + v1 + "," + v2);
            }
            return true;
        }
        /// <summary>
        /// すべての点をとおるパスを深さ優先で列挙する
        /// </summary>
        /// <param name="start"></param>
        /// <returns></returns>
        public IEnumerable<int[]> EnumeratePathesDFS(int start)
        {
            return enumeratePathes(start, new int[] { });
        }
        private IEnumerable<int[]> enumeratePathes(int v, int[] accessed)
        {
            accessed = accessed.Concat(new[] { v }).ToArray();
            if (accessed.Length == this.VertexCount)
            {
                yield return accessed;
                yield break;
            }

            var nexts = this.nodeDic[v].AllNexts();
            
            foreach (var node in nexts)
            {
                if (accessed.Contains(node)) continue;

                foreach (var path in enumeratePathes(node, accessed))
                {
                    yield return path;
                }
            }
        }

        /// <summary>
        /// 指定した始点からの到達点を幅優先で列挙する
        /// </summary>
        /// <param name="start"></param>
        /// <returns></returns>
        public IEnumerable<VertexAndStep> EnumerateVertexesBFS(int start)
        {
            var queue = new Queue<VertexAndStep>();
            queue.Enqueue(new VertexAndStep(start, 0));

            var accessed = new HashSet<int>();

            while(queue.Any())
            {
                var item = queue.Dequeue();
                accessed.Add(item.vertex);
                yield return item;

                var node = this.nodeDic[item.vertex];

                foreach (var next in node.AllNexts())
                {
                    if (accessed.Contains(next)) continue;
                    //if (queue.Any(q => q.vertex == next)) continue;

                    queue.Enqueue(new VertexAndStep(next, item.step + 1));
                }
            }

        }

        public bool HasEdge(int v1, int v2)
        {
            return this.nodeDic[v1].HasNext(v2);
        }


        /// <summary>
        /// グラフが連結かどうかを深さ優先で調べる
        /// </summary>
        /// <returns></returns>
        public bool IsConnectedDFS()
        {
            return isConnectedDfs(1, new HashSet<int>());
        }

        private bool isConnectedDfs(int v, HashSet<int> accessed)
        {
            accessed.Add(v);
            if (accessed.Count == this.VertexCount) return true;

            foreach (var node in this.nodeDic[v].AllNexts())
            {
                if (accessed.Contains(node)) continue;

                if (isConnectedDfs(node, accessed)) return true;
            }
            return false;
        }

        public bool RemoveEdge(int v1, int v2)
        {
            if (this.nodeDic[v1].RemoveNext(v2))
            {
                if (!this.nodeDic[v2].RemoveNext(v1))
                {
                    throw new InvalidProgramException("invalid state " + v1 + "," + v2);
                }
                return true;
            }
            return false;
        }
    }
    
    static class IOUtils
    {
        // public static (int a, int b) Read2Ints()
        // {
        //     var vals = ReadInts();
        //     return (vals[0], vals[1]);
        // }
        // public static (int a, int b, int c) Read3Ints()
        // {
        //     var vals = ReadInts();
        //     return (vals[0], vals[1], vals[2]);
        // }
        public static IEnumerable<int[]> ReadIntLines(int count)
        {
            for (int i = 0; i < count; i++)
            {
                yield return ReadInts();
            }
        }
        public static IEnumerable<long[]> ReadLongLines(int count)
        {
            for (int i = 0; i < count; i++)
            {
                yield return ReadLongs();
            }
        }
        public static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }
        public static long ReadLong()
        {
            return long.Parse(Console.ReadLine());
        }
        public static ulong ReadUlong()
        {
            return ulong.Parse(Console.ReadLine());
        }
        public static int[] ReadInts()
        {
            return Console.ReadLine().Split(' ').Select(v => int.Parse(v)).ToArray();
        }
        public static long[] ReadLongs()
        {
            return Console.ReadLine().Split(' ').Select(v => long.Parse(v)).ToArray();
        }

        public static void WriteNums(params int[] nums)
        {
            Console.WriteLine(string.Join(" ", nums));
        }
    }



    /// <summary>
    /// ダイクストラ法で最短経路を計算
    /// </summary>
    class Dijkstra
    {
        readonly int vertexCount;
        readonly bool hasDirection;
        readonly IReadOnlyDictionary<int, Node> nodeDic;

        int? start;
        int? goal;

        public struct Edge
        {
            public readonly int dest;
            public readonly int weight;

            public Edge(int dest, int weight)
            {
                this.dest = dest;
                this.weight = weight;
            }
        }

        class Node
        {
            public int V { get; }
            private readonly Dictionary<int, Edge> nextDic = new Dictionary<int, Edge>();

            public Node(int v)
            {
                this.V = v;
            }

            public bool HasNext(int v)
            {
                return this.nextDic.ContainsKey(v);
            }
            public void AddNext(int v, int weight)
            {
                if (v == this.V) throw new ArgumentException("ループには対応していません");
                this.nextDic[v] = new Edge(v, weight);
            }
            public IReadOnlyCollection<Edge> AllNexts()
            {
                return this.nextDic.Values;
            }
            public bool RemoveNext(int v)
            {
                return this.nextDic.Remove(v);
            }
            public int? TryGetWeight(int v)
            {
                Edge res;
                return this.nextDic.TryGetValue(v, out res) ? res.weight : (int?)null;
            }

            public int? CurrentWeight { get; private set; }
            public int? CurrentPreVertex { get; private set; }
            //public bool IsCommitted { get; private set; }
            //public void Commit()
            //{
            //    this.IsCommitted = true;
            //}

            public bool TryUpdateWeight(int weight, int? pre)
            {
//                if (this.IsCommitted) return false;
                if (CurrentWeight == null || weight < CurrentWeight.Value)
                {
                    this.CurrentPreVertex = pre;
                    this.CurrentWeight = weight;
                    return true;
                }
                return false;
            }

        }

        public Dijkstra(int vertexCount, bool hasDirection)
        {
            this.vertexCount = vertexCount;
            this.hasDirection = hasDirection;

            this.nodeDic = Enumerable.Range(1, vertexCount)
                                .ToDictionary(v => v, v => new Node(v));
        }
        public void AddEdge(int v1, int v2, int weight)
        {
            if (weight < 0) throw new ArgumentOutOfRangeException(nameof(weight));
            this.nodeDic[v1].AddNext(v2, weight);
            if (!this.hasDirection)
            {
                this.nodeDic[v2].AddNext(v1, weight);
            }
        }
        public bool RemoveEdge(int v1, int v2)
        {
            if (!this.nodeDic[v1].RemoveNext(v2)) return false;
            if (!this.hasDirection)
            {
                if (!this.nodeDic[v2].RemoveNext(v1))
                {
                    throw new InvalidProgramException("invalid state " + v1 + "," + v2);
                }
            }
            return true;
        }

        public void Calc(int start, int? goal)
        {
            if (this.start.HasValue)
            {
                throw new InvalidOperationException("計算実行済み");
            }
            this.start = start;
            this.goal = goal;

            var queue = new PriorityQueue<Node>(vertexCount, n => (n.CurrentWeight ?? 0) * -1);
            this.nodeDic[start].TryUpdateWeight(0, null);
            queue.Enqueue(this.nodeDic[start]);

            while (queue.Count > 0)
            {
                var pre = queue.Dequeue();
//                pre.Commit();
                if (goal != null && pre.V == goal) break;

                foreach (var edge in pre.AllNexts())
                {
                    var newWeight = pre.CurrentWeight.Value + edge.weight;
                    var nextNode = this.nodeDic[edge.dest];

                    if (nextNode.TryUpdateWeight(newWeight, pre.V))
                    {
                        queue.Enqueue(this.nodeDic[edge.dest]);
                    }
                }
            }
        }

        public int? GetPreVertex(int v)
        {
            if (this.start == null) throw new InvalidOperationException("計算未実行");

            return this.nodeDic[v].CurrentPreVertex;
        }
        public int? GetWeight(int v)
        {
            if (this.start == null) throw new InvalidOperationException("計算未実行");

            return this.nodeDic[v].CurrentWeight;
        }

        public List<int> GetRoute(int v)
        {
            if (this.start == null) throw new InvalidOperationException("計算未実行");

            var revList = new List<int>();
            revList.Add(v);
            var last = v;
            while(true)
            {
                if (last == this.start) break;

                var node = this.nodeDic[last].CurrentPreVertex;
                if (node == null) break;
                last = node.Value;
                revList.Add(node.Value);
            }
            revList.Reverse();
            return revList;
        }


    }

       class PriorityQueue<T>
    {
        readonly T[] array;
        readonly Func<T, int> valueSelector;
        public int Count { get; private set; }


        public PriorityQueue(int capacity, Func<T, int> valueSelector)
        {
            this.array = new T[capacity];
            this.valueSelector = valueSelector;
        }

        public void Enqueue(T item)
        {
            this.array[this.Count] = item;
            this.Count += 1;
            this.UpHeap();
        }

        public T Dequeue()
        {
            // 先頭要素を末尾にして再構成
            this.Swap(0, this.Count - 1);
            this.Count -= 1;
            this.DownHeap();

            return this.array[this.Count];
        }


        private void UpHeap()
        {
            var n = this.Count - 1;
            while (n != 0)
            {
                // 親要素の座標
                var parent = (n - 1) / 2;

                if (this.valueSelector(this.array[n]) > this.valueSelector(this.array[parent]))
                {
                    this.Swap(n, parent);
                    n = parent;
                }
                else
                {
                    break;
                }
            }
        }

        private void DownHeap()
        {
            var parent = 0;
            while (true)
            {
                var child = 2 * parent + 1;
                if (child > this.Count - 1) break;

                if (child < this.Count - 1 && this.valueSelector(this.array[child]) < this.valueSelector(this.array[child + 1]))
                {
                    // 左より右の子のほうが大きい値の場合、右を入れ替え対象にする
                    child += 1;
                }

                if (this.valueSelector(this.array[parent]) < this.valueSelector(this.array[child]))
                {
                    this.Swap(parent, child);
                    parent = child;
                }
                else
                {
                    break;
                }
            }
        }

        private void Swap(int a, int b)
        {
            var tmp = this.array[a];
            this.array[a] = this.array[b];
            this.array[b] = tmp;
        }
    }
}


Measured memory_bytes: 59284