Problem:
Twin Prime

Prime numbers are widely applied for cryptographic and communication technology.
A twin prime is a prime number that differs from another prime number by 2.
For example, (5, 7) and (11, 13) are twin prime pairs.

In this problem, we call the greater number of a twin prime "size of the twin prime."

Your task is to create a program which reads an integer n and prints a twin prime which has the maximum size among twin primes less than or equals to n

You may assume that 5 ≤ n ≤ 10000.

Input

The input is a sequence of datasets. The end of the input is indicated by a line containing one zero. Each dataset is formatted as follows:

n (integer)

Output

For each dataset, print the twin prime p and q (p < q). p and q should be separated by a single space.

Sample Input

12
100
200
300
0

Output for the Sample Input

5 7
71 73
197 199
281 283

Solution in Rust (judge verdict: Accepted)

/*input
12
100
200
300
0
*/
fn read_line() -> String {
    let mut return_ = format!("");
    std::io::stdin().read_line(&mut return_).ok();
    return_.pop();
    return_
}

//Sieve of Eratosthenes
fn sieve_of_eratosthenes(n: usize) -> Vec<bool> {
    let mut vec: Vec<bool> = vec![true; n];
    vec[0] = false;
    vec[1] = false;
    let mut j: usize;
    for i in 2..n {
        if vec[i] {
            j = i * i;
            while j < n {
                vec[j] = false;
                j = j + i;
            }
        }
    }
    vec
    /*let mut vec2: Vec<usize> = vec![];
    for i in 0..vec.len() {
        if vec[i] {
            vec2.push(i);
        }
    }
    vec2*/
}

fn main() {
    let soe = sieve_of_eratosthenes(10001);
    let mut input: i32;
    let mut index: i32;
    let mut prime: [i32; 2];
    let mut prime_fill_1: bool;
    loop {
        input = read_line().parse().unwrap();
        //println!(">{:?}", input);
        if input == 0 {
            break;
        }
        index = input;
        prime = [0; 2];
        prime_fill_1 = true;
        loop {
            if soe[index as usize] {
                if prime_fill_1 {
                    prime[1] = prime[0];
                    prime[0] = index;
                    prime_fill_1 = false;
                } else {
                    prime[1] = prime[0];
                    prime[0] = index;
                    prime_fill_1 = true;
                }
            }
            //println!("{:?} -> {:?} {:?}", index, prime[1], prime[0]);
            if (prime[1] - prime[0]).abs() == 2 {
                println!("{} {}", prime[0], prime[1]);
                break;
            }
            index = index - 1;
        }
    }
}