Problem: Little Petya has a birthday soon. Due this wonderful event, Petya's friends decided to give him sweets. The total number of Petya's friends equals to n.

Let us remind you the definition of the greatest common divisor: GCD(a1, ..., ak) = d, where d represents such a maximal positive number that each ai (1 ≤ i ≤ k) is evenly divisible by d. At that, we assume that all ai's are greater than zero.

Knowing that Petya is keen on programming, his friends has agreed beforehand that the 1-st friend gives a1 sweets, the 2-nd one gives a2 sweets, ..., the n-th one gives an sweets. At the same time, for any i and j (1 ≤ i, j ≤ n) they want the GCD(ai, aj) not to be equal to 1. However, they also want the following condition to be satisfied: GCD(a1, a2, ..., an) = 1. One more: all the ai should be distinct.

Help the friends to choose the suitable numbers a1, ..., an.

Input

The first line contains an integer n (2 ≤ n ≤ 50).

Output

If there is no answer, print "-1" without quotes. Otherwise print a set of n distinct positive numbers a1, a2, ..., an. Each line must contain one number. Each number must consist of not more than 100 digits, and must not contain any leading zeros. If there are several solutions to that problem, print any of them.

Do not forget, please, that all of the following conditions must be true:

  * For every i and j (1 ≤ i, j ≤ n): GCD(ai, aj) ≠ 1
  * GCD(a1, a2, ..., an) = 1
  * For every i and j (1 ≤ i, j ≤ n, i ≠ j): ai ≠ aj



Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).

Examples

Input

3


Output

99
55
11115


Input

4


Output

385
360
792
8360

Solution (in JAVA):

Solution:
import java.io.*;
import java.math.BigInteger;
import java.util.*;

/**
 * User: Sasha
 * Date: 24.02.11
 * Time: 21:45
 */
public class Main implements Runnable {
    private static BufferedScanner sc = new BufferedScanner();
    private static BufferedWriter out = new BufferedWriter(new PrintWriter(System.out));

    List<BigInteger> primes = new ArrayList<BigInteger>();

    boolean b[] = new boolean[100100];

    int pari, parj;

    boolean check(BigInteger v[]) {
            for (int i = 0; i < v.length; ++i) {
                    for (int j = i + 1; j < v.length; ++j) {
                            if (v[i].equals(v[j]) || v[i].gcd(v[j]).equals(BigInteger.ONE)) {
                                    pari = i;
                                    parj = j;
                                    return false;
                            }
                    }
            }
            return true;
    }

    private void solve() throws IOException, FileNotFoundException {
        int len = 70000;
        b[0] = b[1] = true;
        for (int i = 2; i * i < len; ++i) {
            if (!b[i]) {
                for (int j = i * i; j < len; j += i) {
                    b[j] = true;
                }
            }
        }
        for (int i = 2; i < len; ++i) {
            if (!b[i]) {
                primes.add(new BigInteger("" + i));
            }
        }
//        while (true) {
            int n = sc.nextInt();

            if (n == 2) {
                out.write("-1");
                return;
            }
            int cnt = 0;
            BigInteger []res = new BigInteger[n];
            for (int i = 0; i < n; ++i) {
                res[i] = BigInteger.ONE;
            }
            for (int i = 0; i < n - 1; ++i) {
                res[i] = new BigInteger("" + primes.get(cnt).toString());
            }
            ++cnt;

            while (!check(res)) {
                if (res[pari].equals(res[parj])) {
                    for (int i = 0; i < n; ++i) {
                        if (i != parj) {
                            res[i] = res[i].multiply(primes.get(cnt));
                        }
                    }
                } else {
                    int s = 0;
                    for (int i = 0; i < n; ++i) {
                        if (i != parj && i != pari && s == 0) {
                            s = 1;
                        } else {
                            res[i] = res[i].multiply(primes.get(cnt));
                        }
                    }
                }
                ++cnt;

                }
                for (int i = 0; i < n; ++i) {
                    out.write(res[i].toString() + '\n');
                }
            out.flush();
//        }
    }


    public void run() {
        try {
            long time = System.currentTimeMillis();
            solve();
            out.flush();
            System.err.println("Time: " + (System.currentTimeMillis() - time));
        } catch(IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String args[]) {
        new Thread(null, new Main(), "ACM-solution", 1<<22).start();
    }

    private static class BufferedScanner {
        private BufferedReader bufferedReader;
        private StringTokenizer stringTokenizer = new StringTokenizer("");

        public BufferedScanner() {
            bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        }

        public BufferedScanner(Reader r) {
            bufferedReader = new BufferedReader(r);
        }

        public BufferedScanner(InputStream stream) {
            bufferedReader = new BufferedReader(new InputStreamReader(stream));
        }

        public boolean hasNext() throws IOException {
            boolean answer = true;
            while (!stringTokenizer.hasMoreElements()) {
                String nextLine = bufferedReader.readLine();
                if (nextLine != null) {
                    stringTokenizer = new StringTokenizer(nextLine);
                } else {
                    answer = false;
                    break;
                }
            }
            return answer;
        }

        public String next() throws IOException {
            if (hasNext()) {
                return stringTokenizer.nextToken();
            }
            throw new NoSuchElementException();
        }

        public Integer nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        public Long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        public Double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        public Integer[] nextInts(int n) throws IOException {
            Integer arr[] = new Integer[n];
            for (int i = 0; i < n; ++i) {
                arr[i] = nextInt();
            }
            return arr;
        }

        public Double[] nextDoubles(int n) throws IOException {
            Double arr[] = new Double[n];
            for (int i = 0; i < n; ++i) {
                arr[i] = nextDouble();
            }
            return arr;
        }

        public Long[] nextLongs(int n) throws IOException {
            Long arr[] = new Long[n];
            for (int i = 0; i < n; ++i) {
                arr[i] = nextLong();
            }
            return arr;
        }

        public String[] nextStrings(int n) throws IOException {
            String arr[] = new String[n];
            for (int i = 0; i < n; ++i) {
                arr[i] = next();
            }
            return arr;
        }
    }
}