#[allow(unused_macros)]
macro_rules! input {
    ( $($t:ty),* ) => {{
        let mut s = String::new();
        std::io::stdin().read_line(&mut s);
        let mut splits = s.trim().split_whitespace();
        ($( { splits.next().unwrap().parse::<$t>().unwrap() },)*)
    }}
}

#[allow(dead_code)]
fn primes(n: u64) -> Vec<u64> {
    if n < 3 {
        return vec![];
    }
    let mut res: Vec<u64> = vec![2];
    for i in 3..n {
        let i = i as u64;
        let root = ((n as f64).sqrt().ceil() as usize + 1) as u64;
        let composite = res.iter().take_while(|&&x| x <= root).any(|x| i % x == 0);
        if !composite {
            res.push(i);
        }
    }
    return res;
}

fn prime_factorization(n: u64) -> std::collections::HashMap<u64, u32> {
    let primes = primes((n / 2) + 2);
    let mut h = std::collections::HashMap::new();

    let mut current = n;
    while current != 1 {
        let mut found = false;
        for p in &primes {
            if current % p == 0 {
                let count = h.entry(*p).or_insert(0);
                *count += 1;
                current /= p;
                found = true;
            }
        }
        if !found {
            let count = h.entry(n).or_insert(0);
            *count += 1;
            break;
        }
    }

    return h;
}

fn same_all(v: &Vec<u32>) -> Option<u32> {
    let first = v[0];
    let same_all = v.iter().all(|&a| a == first);
    
    if same_all {
        Some(first)
    } else {
        None
    }
}

#[allow(dead_code)]
fn divisors(n: u64) -> Vec<u64> {
    let mut res = vec![];
    for i in (1..(((n as f64).sqrt().floor() as u64) + 1)).rev() {
        if n % i == 0 {
            res.insert(0, i);
            if i != n / i {
                res.push(n / i);
            }
        }
    }
    return res;
}

#[allow(unused_must_use)]
#[allow(unused_variables)]
fn solve() {
    let (n,) = input!(u64);

    if n == 0 || n == 1 {
        println!("{}", n);
        return;
    }

    let h = prime_factorization(n);

    let vals: Vec<u32> = h.values().map(|&a| a).collect();

    if let Some(a) = same_all(&vals) {
        if a == 1 && vals.len() == 1 {
            println!("Sosu!");
            return;
        } else if a % 2 == 0 {
            println!("Heihosu!");
            return;
        } else if a % 3 == 0 {
            println!("Ripposu!");
            return;
        }
    }

    let divs = divisors(n);
    let divisor_total: &u64 = &divs[..(divs.len() - 1)].iter().sum();

    if divisor_total == &n {
        println!("Kanzensu!");
        return;
    }

    println!("{}", n);
}

fn main() {
    solve();
}