Problem:
Score : 400 points

Problem Statement

Give a pair of integers (A, B) such that A^5-B^5 = X.
It is guaranteed that there exists such a pair for the given integer X.

Constraints

1 \leq X \leq 10^9

X is an integer.

There exists a pair of integers (A, B) satisfying the condition in Problem Statement.

Input

Input is given from Standard Input in the following format:

X

Output

Print A and B, with space in between.
If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.

A B

Sample Input 1

33

Sample Output 1

2 -1

For A=2 and B=-1, A^5-B^5 = 33.

Sample Input 2

1

Sample Output 2

0 -1

Solution in Rust (1.42.0) (judge verdict: Accepted)

// This code is generated by [cargo-atcoder](https://github.com/tanakh/cargo-atcoder)
// Original source code:
/*
use std::collections::LinkedList;
use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let x: i64 = read();

    for i in -200..200 {
        for j in -200..200 {
            if pow5(i) - pow5(j) == x {
                println!("{} {}", i, j);
                return;
            }
        }
    }
}

fn pow5(i: i64) -> i64 {
    i * i * i * i * i
}

fn prime_lists(limit: u64) -> LinkedList<u64> {
    let mut ret: LinkedList<u64> = LinkedList::new();
    ret.push_back(2);
    let mut i: u64 = 3;

    while i * i <= limit {
        if (&ret).into_iter().fold(true, |a, &b| a && i % b != 0) {
            ret.push_back(i);
        }
        i += 2;
    }
    ret
}

fn factorize(fact: u64) -> Vec<u64> {
    let mut i = fact;
    let mut ret: Vec<u64> = Vec::new();
    let primes = prime_lists(fact);
    println!("a");
    for p in &primes {
        while i % p == 0 {
            ret.push(*p);
            i /= p;
        }
    }
    ret
}

fn factorize_all(fact: u64) -> Vec<u64> {
    let mut factorized = factorize(fact);
    let mut ret: Vec<u64> = Vec::with_capacity(factorized.len() * factorized.len());
    ret.push(1);

    while factorized.len() > 0 {
        let n = factorized.remove(0);
        let pushed = (&ret).into_iter().map(|&b| b * n).collect::<Vec<u64>>();
        for other in &pushed {
            ret.push(*other);
        }
    }
    ret.dedup();
    ret
}
*/

fn main() {
    let exe = "/tmp/binE1FC8048";
    std::io::Write::write_all(&mut std::fs::File::create(exe).unwrap(), &decode(BIN)).unwrap();
    std::fs::set_permissions(exe, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
    std::process::exit(std::process::Command::new(exe).status().unwrap().code().unwrap())
}

fn decode(v: &str) -> Vec<u8> {
    let mut ret = vec![];
    let mut buf = 0;
    let mut tbl = vec![64; 256];
    for i in 0..64 { tbl[TBL[i] as usize] = i as u8; }
    for (i, c) in v.bytes().filter_map(|c| { let c = tbl[c as usize]; if c < 64 { Some(c) } else { None } }).enumerate() {
        match i % 4 {
            0 => buf = c << 2,
            1 => { ret.push(buf | c >> 4); buf = c << 4; }
            2 => { ret.push(buf | c >> 2); buf = c << 6; }
            3 => ret.push(buf | c),
            _ => unreachable!(),
        }
    }
    ret
}

const TBL: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const BIN: &'static str = "<base64-encoded ELF executable removed>";