using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;

namespace CF
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            using (var sr = new InputReader(Console.In))
            //using (var sr = new InputReader(new StreamReader("input.txt")))
            {
                var task = new Task();
                using (var sw = Console.Out) {
                    //using (var sw = new StreamWriter("output.txt")) {
                    task.Solve(sr, sw);
                    //Console.ReadKey();
                }
            }
        }
    }

    internal class Task
    {
        public void Solve(InputReader sr, TextWriter sw)
        {
            var n = sr.NextInt32();
            var graph = new Graph(n);
            for (var i = 0; i < n - 1; i++) {
                var input = sr.ReadArrayOfInt32();
                graph.Insert(input[0] - 1, input[1] - 1);
            }
            sw.WriteLine(graph.Solution());
        }
    }

    class Graph
    {
        private readonly List<int>[] edges;
        private readonly Color[] colors;

        public Graph(int n)
        {
            edges = new List<int>[n];
            colors = new Color[n];
        }

        public void Insert(int x, int y)
        {
            if (edges[x] == null) {
                edges[x] = new List<int>();
            }
            edges[x].Add(y);
            if (edges[y] == null) {
                edges[y] = new List<int>();
            }
            edges[y].Add(x);
        }

        public string Solution()
        {
            var path = new List<int>();
            var visited = new bool[edges.Length];
            DfsVisit(0, visited, path);
            path.RemoveAt(0);
            for (var i = 0; i < path.Count / 2; i++) {
                var v = path[i];
                colors[v] = Color.Black;
                var revV = path[path.Count - 1 - i];
                colors[revV] = Color.White;
            }
            if (path.Count % 2 == 1) {
                colors[path[(path.Count - 1) / 2]] = Color.Black;
            }
            colors[0] = Color.Black;
            colors[edges.Length - 1] = Color.White;
            var isFennecLast = path.Count % 2 == 1;
            var fennecSteps = 0;
            var snukeSteps = 0;
            for (var i = 0; i < edges.Length; i++) {
                if (colors[i] == Color.Black) {
                    fennecSteps += DfsVisit(i, 0, Color.Black);
                }
            }
            for (var i = 0; i < edges.Length; i++)
            {
                if (colors[i] == Color.White)
                {
                    snukeSteps += DfsVisit(i, 0, Color.White);
                }
            }
            if (isFennecLast) {
                if (fennecSteps >= snukeSteps) {
                    return "Fennec";
                }
                return "Snuke";
            }
            else {
                if (snukeSteps >= fennecSteps) {
                    return "Snuke";
                }

                return "Fennec";
            }
        }

        private int DfsVisit(int v, int curr, Color color)
        {
            colors[v] = color;
            var result = curr;
            for (var i = 0; i < edges[v].Count; i++) {
                if (colors[edges[v][i]] == Color.None) {
                    var next = DfsVisit(edges[v][i], curr + 1, color);
                    result += (next - curr);
                }
            }

            return result;
        }

        private bool DfsVisit(int v, bool[] visited, List<int> path)
        {
            if (v == edges.Length - 1)
                return true;
            visited[v] = true;
            path.Add(v);
            for (var i = 0; i < edges[v].Count; i++) {
                if (!visited[edges[v][i]]) {
                    if (DfsVisit(edges[v][i], visited, path)) {
                        return true;
                    }
                }
            }
            path.RemoveAt(path.Count - 1);
            return false;
        }
    }

    enum Color
    {
        None,
        White,
        Black
    }
}

internal class InputReader : IDisposable
{
    private bool isDispose;
    private readonly TextReader sr;

    public InputReader(TextReader stream)
    {
        sr = stream;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    public string NextString()
    {
        var result = sr.ReadLine();
        return result;
    }

    public int NextInt32()
    {
        return Int32.Parse(NextString());
    }

    public long NextInt64()
    {
        return Int64.Parse(NextString());
    }

    public string[] NextSplitStrings()
    {
        return NextString()
            .Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
    }

    public T[] ReadArray<T>(Func<string, CultureInfo, T> func)
    {
        return NextSplitStrings()
            .Select(s => func(s, CultureInfo.InvariantCulture))
            .ToArray();
    }

    public int[] ReadArrayOfInt32()
    {
        return ReadArray(Int32.Parse);
    }

    public long[] ReadArrayOfInt64()
    {
        return ReadArray(Int64.Parse);
    }

    public T[] ReadArrayFromString<T>(Func<string, CultureInfo, T> func, string str)
    {
        return
            str.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
                .Select(s => func(s, CultureInfo.InvariantCulture))
                .ToArray();
    }

    protected void Dispose(bool dispose)
    {
        if (!isDispose) {
            if (dispose)
                sr.Close();
            isDispose = true;
        }
    }

    ~InputReader()
    {
        Dispose(false);
    }
}

Measured memory_bytes: 32676