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)

#![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 func(a: i64, b: i64) -> i64 {
    a * a * a * a + a * a * a * b + a * a * b * b + a * b * b * b + b * b * b * b
}

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));
        }
    }
    */

    // debug!(pairs);
    for a in 0..1001 {
        for b in 0..a + 1 {
            if pw5(a) - pw5(b) == x {
                println!("{} {}", a, b);
                return;
            }
        }
    }
    /*
    let crite
    for (a_m_b, val) in pairs {
        let (ok, ng) = binary_search(0, 1000, criterion);
        /*
        for a in 0..x + 1 {
            if pw5(a) > 1000000000000000 {
                break;
            }
            let b = a - a_m_b;
            if b < 0 {
                continue;
            }
            if func(a, b) == val {
                println!("{} {}", a, b);
                return;
            }
            if pw5(a) - pw5(b) == x {
                println!("{} {}", a, b);
                return;
            }
        }
        */
    }
    */
}

fn binary_search<F>(lb: usize, ub: usize, criterion: F) -> (usize, usize)
where
    F: Fn(usize) -> bool,
{
    let mut ok = lb;
    let mut ng = ub;
    while ng - ok > 1 {
        let mid = (ng + ok) / 2;
        if criterion(mid) {
            ok = mid;
        } else {
            ng = mid;
        }
    }
    (ok, ng)
}

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()
}