use std::io;

const MAX_ELEMENT: i64 = 30000;

fn main() {
    let mut line = String::new();
    io::stdin().read_line(&mut line).unwrap();
    let inputs = line.as_str().split(' ').collect::<Vec<&str>>();
    let input0 = inputs[0].trim().parse::<usize>().unwrap();

    print!(
        "{}",
        special_set(input0)
            .into_iter()
            .map(|v| format!("{}", v))
            .collect::<Vec<String>>()
            .join(" ")
    );
}

fn special_set(n: usize) -> Vec<i64> {
    if n == 3 {
        vec![2, 5, 63]
    } else if n == 4 {
        vec![2, 5, 20, 63]
    } else {
        let mut set = Vec::<i64>::new();
        for i in 3..MAX_ELEMENT + 1 {
            if i % 2 == 0 || i % 3 == 0 || i % 5 == 0 {
                set.push(i);
            }
            if set.len() == n - 1 {
                break;
            }
        }

        let mut sum = set.iter().fold(0, |acc, v| acc + v);
        if sum % 2 != 0 {
            set[0] = 2;
            sum -= 1;
        }

        let last = if sum % 3 != 0 && sum % 5 == 0 {
            let mut v = 0;
            for k in 1..3 {
                if (MAX_ELEMENT - 30 + 10 * k) % 3 == 3 - (sum % 3) {
                    v = MAX_ELEMENT - 30 + 10 * k;
                    break;
                }
            }
            v
        } else if sum % 3 == 0 && sum % 5 != 0 {
            let mut v = 0;
            for k in 1..5 {
                if (MAX_ELEMENT - 30 + 6 * k) % 5 == 5 - (sum % 5) {
                    v = MAX_ELEMENT - 30 + 6 * k;
                    break;
                }
            }
            v
        } else if sum % 3 != 0 && sum % 5 != 0 {
            let mut v = 0;
            for k in 1..15 {
                if (MAX_ELEMENT - 30 + 2 * k) % 5 == 5 - (sum % 5)
                    && (MAX_ELEMENT - 30 + 2 * k) % 3 == 3 - (sum % 3)
                {
                    v = MAX_ELEMENT - 30 + 2 * k;
                    break;
                }
            }
            v
        } else {
            MAX_ELEMENT
        };
        set.push(last);
        set
    }
}

fn is_special_set(set: &[i64]) -> bool {
    let mut flag = true;
    for i in 0..set.len() {
        let sum = set.iter()
            .enumerate()
            .fold(0, |acc, (j, v)| if j == i { acc } else { acc + v });
        flag &= gcd(sum, set[i]) > 1;
    }
    flag
}

fn gcd(a: i64, b: i64) -> i64 {
    let (m, n) = if a >= b { (a, b) } else { (b, a) };
    if n == 0 {
        m
    } else {
        gcd(n, m % n)
    }
}

#[cfg(test)]
mod test {
    use super::*;

    fn assert(input: usize) {
        let output = special_set(input);
        assert!(
            is_special_set(&output),
            "{:?} is not a special set",
            &output
        )
    }

    #[test]
    fn test_special_set_3() {
        assert(3);
    }

    #[test]
    fn test_special_set_4() {
        assert(4);
    }

    #[test]
    fn test_special_set_5() {
        assert(5);
    }

    #[test]
    fn test_special_set_103() {
        assert(103);
    }

    #[test]
    fn test_gcd() {
        assert_eq!(gcd(6, 9), 3);
    }

    #[test]
    fn test_is_special_set_2_5_63_should_be_true() {
        assert!(is_special_set(&[2, 5, 63]));
    }

    #[test]
    fn test_is_special_set_2_4_7_should_be_false() {
        assert!(!is_special_set(&[2, 4, 7]));
    }
}


Measured memory_bytes: 4476