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: Wrong Answer)

#![allow(unused_imports)]
#![allow(non_snake_case)]
use std::cmp::*;
use std::collections::*;
use std::io::Write;

#[allow(unused_macros)]
macro_rules! debug {
    ($($e:expr),*) => {
        #[cfg(debug_assertions)]
        $({
            let (e, mut err) = (stringify!($e), std::io::stderr());
            writeln!(err, "{} = {:?}", e, $e).unwrap()
        })*
    };
}

fn pw5(x: i64) -> i64 {
    x * x * x * x * x
}

fn main() {
    let x = read::<i64>();
    let mut max_i = 0;
    for i in 1.. {
        if pw5(i) > x {
            max_i = i - 1;
            break;
        }
    }

    for a in 0..max_i + 1 {
        for b in a..max_i + 1 {
            if pw5(a) + pw5(b) == x {
                println!("{} {}", a, -b);
                return;
            }
        }
    }

    /*
    let mut pairs = vec![];
    for i in 1.. {
        if i * i > x {
            break;
        }
        if x % i == 0 {
            pairs.push((i, x / i));
            pairs.push((x / i, i));
        }
    }

    for (a_m_b, val) in pairs {

    }
    */
}

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}