Problem:
Score : 600 points

Problem Statement

Nagase is a top student in high school. One day, she's analyzing some properties of special sets of positive integers.

She thinks that a set S = \{a_{1}, a_{2}, ..., a_{N}\} of distinct positive integers is called special if for all 1 \leq i \leq N, the gcd (greatest common divisor) of a_{i} and the sum of the remaining elements of S is not 1.

Nagase wants to find a special set of size N. However, this task is too easy, so she decided to ramp up the difficulty. Nagase challenges you to find a special set of size N such that the gcd of all elements are 1 and the elements of the set does not exceed 30000.

Constraints

3 \leq N \leq 20000

Input

Input is given from Standard Input in the following format:

N

Output

Output N space-separated integers, denoting the elements of the set S. S must satisfy the following conditions :

The elements must be distinct positive integers not exceeding 30000.

The gcd of all elements of S is 1, i.e. there does not exist an integer d > 1 that divides all elements of S.

S is a special set.

If there are multiple solutions, you may output any of them. The elements of S may be printed in any order. It is guaranteed that at least one solution exist under the given contraints.

Sample Input 1

3

Sample Output 1

2 5 63

\{2, 5, 63\} is special because gcd(2, 5 + 63) = 2, gcd(5, 2 + 63) = 5, gcd(63, 2 + 5) = 7. Also, gcd(2, 5, 63) = 1. Thus, this set satisfies all the criteria.

Note that \{2, 4, 6\} is not a valid solution because gcd(2, 4, 6) = 2 > 1.

Sample Input 2

4

Sample Output 2

2 5 20 63

\{2, 5, 20, 63\} is special because gcd(2, 5 + 20 + 63) = 2, gcd(5, 2 + 20 + 63) = 5, gcd(20, 2 + 5 + 63) = 10, gcd(63, 2 + 5 + 20) = 9. Also, gcd(2, 5, 20, 63) = 1. Thus, this set satisfies all the criteria.

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

fn read_line() -> String {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().to_owned()
}

fn reads<T>() -> Vec<T>
where
    T: std::str::FromStr,
    <T as std::str::FromStr>::Err: std::fmt::Debug,
{
    read_line()
        .split_whitespace()
        .map(|w| w.parse().unwrap())
        .collect()
}

fn gcd(a: i32, b: i32) -> i32 {
    if b == 0 {
        a
    } else {
        gcd(b, a % b)
    }
}

fn check(s: &[i32]) {
    let sum: i32 = s.iter().sum();

    for i in 0..s.len() {
        let g = gcd(sum - s[i], s[i]);
        if g == 1 {
            panic!("seq = {:?}, gcd({}, {}) = {}", s, sum - s[i], s[i], g);
        }
    }
}

fn main() {
    let n: i32 = reads()[0];

    if n == 3 {
        println!("2 5 63");
        return;
    } else if n == 4 {
        println!("2 5 20 63");
        return;
    }

    let mut ms = [0; 6];

    for i in 2..30001 {
        if i % 2 == 0 || i % 3 == 0 {
            ms[i % 6] += 1;
        }
    }

    let mut us = [0; 6];
    us[0] = 1;
    us[2] = 1;
    us[3] = 2;
    us[4] = 1;
    let mut rest = n - 5;

    while rest > 0 {
        // println!("rest: {}, us: {:?}, ms{:?}", rest, us, ms);

        if rest >= 2 && us[2] < ms[2] && us[4] < ms[4] {
            us[2] += 1;
            us[4] += 1;
            rest -= 2;
        } else if rest >= 2 && us[3] + 2 <= ms[3] {
            us[3] += 2;
            rest -= 2;
        } else if us[0] < ms[0] {
            us[0] += 1;
            rest -= 1;
        }
    }

    let mut ans = vec![];

    for i in 2..30001 {
        if i % 2 == 0 || i % 3 == 0 {
            if us[i % 6] > 0 {
                us[i % 6] -= 1;
                ans.push(i as i32);
            }
        }
    }

    check(&ans);

    for i in 0..ans.len() {
        if i > 0 {
            print!(" ");
        }
        print!("{}", ans[i]);
    }
    println!();
}