use std::io::{BufRead, Write};
use std::io;

#[derive(Copy, Clone, Eq, PartialEq, Debug)]
enum Color {
    None,
    Black,
    White,
}

fn search(
    current: usize,
    prev: Option<usize>,
    target: usize,
    adjacency: &Vec<Vec<usize>>,
) -> Option<Vec<usize>> {
    // Note: the returned value is in reversed order and lacks the starting point.
    for &x in &adjacency[current] {
        if Some(x) != prev {
            if x == target {
                return Some(vec![x]);
            } else if let Some(mut result) = search(x, Some(current), target, adjacency) {
                result.push(x);
                return Some(result);
            }
        }
    }
    None
}

fn color_nodes(
    current: usize,
    prev: Option<usize>,
    adjacency: &Vec<Vec<usize>>,
    color: Color,
    data: &mut Vec<Color>,
) {
    // Note: the starting point is colored unconditionally.
    for &x in &adjacency[current] {
        if Some(x) != prev {
            if data[x] == Color::None || data[x] == color {
                color_nodes(x, Some(current), adjacency, color, data);
            }
        }
    }
    data[current] = color;
}

fn solve<R: BufRead, W: Write>(mut input: R, mut output: W) {
    let mut s = String::new();
    input.read_line(&mut s).unwrap();
    let n: usize = s.trim().parse().unwrap();
    let mut adjacency = vec![Vec::new(); n];
    for _ in 0..n - 1 {
        s.clear();
        input.read_line(&mut s).unwrap();
        let mut split = s.split_whitespace();
        let a = split.next().unwrap().parse::<usize>().unwrap() - 1;
        let b = split.next().unwrap().parse::<usize>().unwrap() - 1;
        adjacency[a].push(b);
        adjacency[b].push(a);
    }
    for x in &mut adjacency {
        x.sort();
    }
    let mut path = search(0, None, n - 1, &adjacency).unwrap();
    path.push(0);
    path.reverse();
    let mut color: Vec<Color> = vec![Color::None; n];
    let mut it = path.iter();
    loop {
        if let Some(&x) = it.next() {
            color[x] = Color::Black;
        } else {
            break;
        }
        if let Some(&x) = it.next_back() {
            color[x] = Color::White;
        } else {
            break;
        }
    }
    color_nodes(0, None, &adjacency, Color::Black, &mut color);
    color_nodes(n - 1, None, &adjacency, Color::White, &mut color);
    let fen = color.iter().filter(|&&x| x == Color::Black).count();
    let snu = color.iter().filter(|&&x| x == Color::White).count();
    assert_eq!(color.iter().filter(|&&x| x == Color::None).count(), 0);
    writeln!(output, "{}", if fen > snu { "Fennec" } else { "Snuke" }).unwrap();
}

fn main() {
    let stdin = io::stdin();
    let stdout = io::stdout();
    solve(stdin.lock(), stdout.lock());
}

#[cfg(test)]
mod tests {
    fn test(input: &str, output: &str) {
        let mut v: Vec<u8> = Vec::new();
        ::solve(input.as_bytes(), &mut v);
        assert_eq!(String::from_utf8(v).unwrap(), output);
    }
    #[test]
    fn case1() {
        test(
            "7
3 6
1 2
3 1
7 4
5 7
1 4\n",
            "Fennec\n",
        );
    }
    #[test]
    fn case2() {
        test(
            "4
1 4
4 2
2 3\n",
            "Snuke\n",
        );
    }
}


Measured memory_bytes: 28156