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

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.StringTokenizer;

/**
 *
 *
 *
 * @author pttrung
 */
public class D {

    public static long MOD;

    public static void main(String[] args) {
        Scanner in = new Scanner();
        PrintWriter out = new PrintWriter(System.out);
        int n = in.nextInt();
        boolean[] prime = new boolean[300];
        // int count1 = 0;

        for (int i = 2; i < prime.length; i++) {
            if (!prime[i]) {
                // count1++;
                for (int j = i * i; j < prime.length; j += i) {
                    if (j < 0) {
                        break;
                    }
                    prime[j] = true;
                }
            }
        }
        // System.out.println("Total " + count1);

        if (n != 2) {
            out.println(6);
            n--;
            BigInteger val = new BigInteger("3");
            int count = 1;
            for (int i = 4; i < prime.length && count < n; i++) {
                if (!prime[i]) {
                    count++;
                    val = val.multiply(new BigInteger("" + i));
                }
            }
            out.println(val.toString());
            n--;
            count = 0;
            for (int i = 4; i < prime.length && count < n; i++) {
                if (!prime[i]) {
                    count++;
                    out.println(2 * i);
                }
            }
        } else {
            out.println(-1);            
        }


        out.close();
    }

    public static long require(Node node, Node pa) {
        // System.out.println(node.value);
        if (node.children.size() <= 1) {
            return 1;
        } else {
            long result = 1;
            for (int i = 0; i < node.children.size(); i++) {
                if (!node.children.get(i).equals(pa)) {
                    long val = require(node.children.get(i), node);
                    result = result * val / gcd(result, val);
                    node.totalValue += node.children.get(i).totalValue;
                    node.minChild = node.minChild > node.children.get(i).totalValue ? node.children.get(i).totalValue : node.minChild;
                }
            }
            result *= node.children.size() - 1;
            return result;
        }
    }

    public static long cal(Node node, Node pa, long deduce) {
        if (node.countChild() <= 1) {
            if (node.value >= deduce) {
                return node.value - deduce;
            } else {
                return -1;
            }
        }
        long result = 0;
        if (node.value + (node.minChild * (node.countChild() - 1)) >= deduce) {
            long val = deduce / (node.countChild() - 1);
            if (val <= node.minChild) {
            } else {
                result = deduce - (node.minChild * (node.countChild() - 1));
                val = node.minChild;
                if (result > node.value) {
                    return -1;
                }
            }
            for (int i = 0; i < node.children.size(); i++) {
                if (!node.children.get(i).equals(pa)) {
                    long temp = cal(node.children.get(i), node, val);
                    if (temp != -1) {
                        result += temp;
                    } else {
                        return -1;
                    }
                }
            }
            return result;
        }
        return -1;
    }

    public static class Node {

        long value, totalValue, minChild = Long.MAX_VALUE;
        ArrayList<Node> children = new ArrayList();
        Node pa;

        public Node(long value) {
            this.value = value;
            totalValue = value;
        }

        public void add(Node node) {
            children.add(node);
        }

        public long countChild() {
            return children.size();
        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static class Pair implements Comparable<Pair> {

        int a, val;

        public Pair(int a, int val) {
            this.a = a;
            this.val = val;
        }

        @Override
        public int compareTo(Pair o) {
            return val - o.val;
        }
    }

    public static long pow(long a, long b) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2);
        if (b % 2 == 0) {
            return val * val % MOD;
        } else {
            return val * (val * a % MOD) % MOD;
        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

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

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

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}
