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)

use std::io::*;
use std::str::FromStr;
use std::collections::LinkedList;

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 -10000..10001 {
        for j in -1000..10001 {
            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
}