import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class Main {

    private static boolean sameset(int a, int b, int[] uf) {

        return find(a,uf) == find(b,uf);
    }

    private static void union(int a, int b, int[] uf) {
        uf[find(a,uf)] = find(b,uf);
    }

    private static int find(int a, int[] uf) {
        if(a == uf[a])  return a;
        int root = find(uf[a],uf);
        uf[a] = root;
        return root;
    }

    private static void BFS(int i, int[][] G, int[][] path) {
       // System.out.println("source vertex "+i);
        int[] v = new int[G.length]; // current maximum dist in u---v path
        ArrayDeque<Integer> A = new ArrayDeque();
        A.add(i);
        while(A.isEmpty() == false){
            int u = A.pop();
            //System.out.println("for node "+u);
            for(int a=0;a<v.length;a++){
                if(G[u][a] > 0 && v[a]==0 && a!=i){//edge in MST, later make faster
                    //System.out.println(a+" is and edge from "+u);
                    if(G[u][a] > v[u]){
                        //System.out.println(" and it incrases the sub path max ");
                        v[a] = G[u][a];
                    }
                    else    v[a] = v[u];
                    path[i][a] = v[a];
                    path[a][i] = v[a];
                   // System.out.println("finally path from "+i+" to "+a+" is "+path[i][a]);

                    A.add(a);
                }
            }
        }
    }

    private static int numd(int x) {
        Double xx = Double.parseDouble(String.valueOf(x));
        int y = (int) Math.log10(xx);
        return (y+1);

    }

    private static String primeFactor(int n, boolean[] x) {
        String ans = "";
        for(int i=2;i<x.length;i++){
            if(i*i > n) break;
            if(x[i]){
                //System.out.println("testing prome "+i);
                while(n!=1 && i*i <= n){
                    while(n%i==0){
                       // System.out.println(i+" can divide "+n);
                        if(ans.equals(""))  ans=String.valueOf(i);
                        else    ans+=" x "+i;
                        n/=i;
                    }
                    break;
                }
            }
        }
        if(n!=1){
           // System.out.println("Remainig "+n);
            if(ans.equals(""))  ans=String.valueOf(n);
            else    ans+=" x "+n;
        }
        return ans;
    }

    private static String solve(String s) {

        return null;
    }

    //counts the number of divisors using the fundamental theorem of arithmetic
    private static int getDivisorCount(int n) {

        int count = 1;

        int tmp = n;

        for(int i=2;i*i<=n;i=(i==2?3:i+2)){

            //System.out.println(i+" is odd");

            int pow = 0;

            while(n%i==0){
                pow+=1;
                n/=i;
            }

            if(pow != 0){
                ///System.out.println(i+" must be a prime");
                count*=(pow+1);
            }
        }

        if(n!=1){
            //System.out.println(n+" is the last prime factor");
            count*=2;
        }

        //System.out.println("number of divisors of "+tmp+" is "+count);
        return count;
    }

    private static long nchoosek(int n, int k) {

        long prod = 1;
        int j = 1;

        int st = Math.max(n-k, k)+1;
        int ed = Math.min(n-k, k);

        for(int i=st;i<=n;i++){
            for(;j<=ed;j++){
                if(prod%j==0)   prod/=j;
                else break;
            }
            prod*=i;
        }

        for(;j<=ed;j++){
            prod/=j;
        }

        return prod;
    }

    //related to extgcd problems
    private static boolean check() {
        //System.out.println(a+" "+b+" "+c1+" "+c2);
        if(n%ibgcd(a,b)!=0) {
           // System.out.println("not possible");
            return false;
        }

        extgcd(a,b);
        long gcd=0,m1=x,m2=y;
        gcd=d;
        m1*=(n/d);
        m2*=(n/d);
        a/=d;
        b/=d;

        double f1 = (m1/b);f1*=-1;
        double f2 = (m2/a);
        long le = (long) Math.ceil(f1);
        long re = (long) Math.floor(f2);
        if(le > re) return false;
        long cf=c1*b-c2*a;
        if(cf*le < cf*re){

            x = m1+b*le;
            y = m2-a*le;
        }else{
            x = m1+b*re;
            y = m2-a*re;
        }
        //System.out.println("upper and lower are "+le+" "+re);

        return true;
    }

    private static void extgcd(long a, long b) {

        if(b==0){
            x=1;y=0;d=a;return;
        }
        extgcd(b,a%b);
        long x1 = y;
        long y1 = x-(a/b)*y;
        x=x1;
        y=y1;
    }

    private static void floyd_cycle(int z, int I, int m, int x0) {

        int tor = func(z,I,m,x0);
        int har = func(z,I,m,tor); //one step ahead of tor
        //System.out.println("initial value for tor and har "+tor+" "+har);

        while(tor!=har){
            tor = func(z,I,m,tor);
            har = func(z,I,m,har);
            har = func(z,I,m,har);
            //System.out.println("tor and har "+tor+" "+har);
        }

        //at r-x%m now
        int x = 0;
        har = tor;
        tor = x0;

        while(har!=tor){

            tor = func(z,I,m,tor);
            har = func(z,I,m,har);
            x+=1;
            //System.out.println("findind x tor and har "+tor+" "+har);
        }

        //now at first reapting node
        int lam = 1;
        har = func(z,I,m,tor);

        while(har!=tor){
            har = func(z,I,m,har);
            lam+=1;
            //System.out.println("finding lam, tor and har "+tor+" "+har);
        }

       // return new Pair(z,lam);
    }

   private static int func(int z, int I, int m, int x0) {
        return ((z*x0)%m+I%m)%m;
    }

    private static void dfs(int a, int[][] d, int[] v,int[] p) {

        v[a] = 1;
        for(int i=0;i<v.length;i++){
            if(i!=a && d[i][a]!=0){
                if(v[i]==0){
                   // System.out.println("dfsing "+i);
                    p[i]=a;
                    dfs(i,d,v,p);
                }else if(p[a] != i && a<i){
                   // System.out.println(a+" and "+i+" causing cycle"+p[i]);
                    cycle=true;
                }
            }
        }

    }

    private static void dolve(int x, int[] a) {
        //find sors of x
        int cnt = 0;
        for(int i=2;i<=Math.sqrt(x);i=(i==2?3:i+2)){
            int pow = 0;
            while(x%i==0){
                x/=i;
                pow+=1;
            }
            if(pow!=0){
                for(int j=1;j<=pow;j++){
                    long f = (long) Math.pow(i, j);

                    if(f<a.length){
                        a[Integer.parseInt(String.valueOf(f))]=1;
                        //System.out.println("ading "+Integer.parseInt(String.valueOf(f)));
                    }

                }
            }
        }

        if(x!=1){
            //System.out.println("ading "+x);
            if(x<a.length)  a[x]=1;
        }
    }

    private static long search(long max, long tmp, long a, long b) {

        long lo = 0;
        long hi = max;

        while(lo < hi){

            long mid = (lo+hi)>>1;

            long k = mid*a;
            k/=b;
            if(k==tmp)  hi=mid;
            else    lo = mid+1;
        }

        return lo;
    }

    static class Node{

        int d=-1;
        long num;
        public Node(int a,long c){
            this.d = a;

            this.num = c;

        }
    }

    static class Edge{

        String d;
        int p;//ids of nodes
        int q;
        public Edge( String x1, int y1, int w){

            this.d = x1;
            this.p = y1;
            this.q = w;
        }
    }

    //simple sieve
    static boolean[] getPrimes(int n){

        boolean[] ret = new boolean[n+1];
        Arrays.fill(ret, true);

        ret[0] = ret[1] = false;

        for(int i=2;i*i <= n; i++){

            if(ret[i]){

                for(int j=i*i;j<=n;j+=i){

                    ret[j]=false;
                }
            }
        }

        return ret;
    }

    static long ibgcd(long a, long b){

        while(b > 0){
            long r = a%b;
            a=b;
            b=r;
        }
        return a;
    }

    //for extgcd
    static long x,y,d; //output and gdc
    static long c1,c2,a,b,n; // inputs
    //static boolean[] p = getPrimes(5000001);

    static class Pair{
        int a;
        int b;
        int w;
        public Pair(int a, int b, int w){
            this.a=a;
            this.b=b;
            this.w=w;
        }
    }

    static boolean cycle = false;
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new PrintWriter(System.out));

        boolean[] state = getPrimes(10000000);
        String[] _x = br.readLine().split(" ");

        int n = Integer.parseInt(_x[0]);

        int K = Integer.parseInt(_x[1]);

        if(K==0 || (n>>1) > K || n==1)  System.out.println(-1);
        else{
            int[] a = new int[n];
            for(int i=0;i<n;i++){
                a[i] = (i+1);
            }

            int x = K - (n>>1) + 1;
           // System.out.println("remaining "+x);

            int p = x;
            if(x > 1){
                for(int i=2;i<=state.length-1;i++){
                    if(state[i]&&x%i!=0){
                        //System.out.println(x+" "+x*i);
                        p*=i;
                        break;
                    }
                }

                if(x > 100000){
                    a[0]=x;
                    a[1]=p;
                }else{
                    for(int i=0;i<n;i++){
                        if(a[i]==x){
                            if(a[i]%2==0){
                                a[i-1]=x;
                                a[i]=p;
                            }else{
                                a[i]=x;
                                a[i+1]=p;
                            }

                            break;
                        }
                    }
                }

            }

            for(int i=0;i<n;i++){
                bw.append(a[i]+" ");
            }
            bw.append("\n");
        }

        bw.close();
    }

}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class Main {

    private static boolean sameset(int a, int b, int[] uf) {

        return find(a,uf) == find(b,uf);
    }

    private static void union(int a, int b, int[] uf) {
        uf[find(a,uf)] = find(b,uf);
    }

    private static int find(int a, int[] uf) {
        if(a == uf[a])  return a;
        int root = find(uf[a],uf);
        uf[a] = root;
        return root;
    }

    private static void BFS(int i, int[][] G, int[][] path) {
       // System.out.println("source vertex "+i);
        int[] v = new int[G.length]; // current maximum dist in u---v path
        ArrayDeque<Integer> A = new ArrayDeque();
        A.add(i);
        while(A.isEmpty() == false){
            int u = A.pop();
            //System.out.println("for node "+u);
            for(int a=0;a<v.length;a++){
                if(G[u][a] > 0 && v[a]==0 && a!=i){//edge in MST, later make faster
                    //System.out.println(a+" is and edge from "+u);
                    if(G[u][a] > v[u]){
                        //System.out.println(" and it incrases the sub path max ");
                        v[a] = G[u][a];
                    }
                    else    v[a] = v[u];
                    path[i][a] = v[a];
                    path[a][i] = v[a];
                   // System.out.println("finally path from "+i+" to "+a+" is "+path[i][a]);

                    A.add(a);
                }
            }
        }
    }

    private static int numd(int x) {
        Double xx = Double.parseDouble(String.valueOf(x));
        int y = (int) Math.log10(xx);
        return (y+1);

    }

    private static String primeFactor(int n, boolean[] x) {
        String ans = "";
        for(int i=2;i<x.length;i++){
            if(i*i > n) break;
            if(x[i]){
                //System.out.println("testing prome "+i);
                while(n!=1 && i*i <= n){
                    while(n%i==0){
                       // System.out.println(i+" can divide "+n);
                        if(ans.equals(""))  ans=String.valueOf(i);
                        else    ans+=" x "+i;
                        n/=i;
                    }
                    break;
                }
            }
        }
        if(n!=1){
           // System.out.println("Remainig "+n);
            if(ans.equals(""))  ans=String.valueOf(n);
            else    ans+=" x "+n;
        }
        return ans;
    }

    private static String solve(String s) {

        return null;
    }

    //counts the number of divisors using the fundamental theorem of arithmetic
    private static int getDivisorCount(int n) {

        int count = 1;

        int tmp = n;

        for(int i=2;i*i<=n;i=(i==2?3:i+2)){

            //System.out.println(i+" is odd");

            int pow = 0;

            while(n%i==0){
                pow+=1;
                n/=i;
            }

            if(pow != 0){
                ///System.out.println(i+" must be a prime");
                count*=(pow+1);
            }
        }

        if(n!=1){
            //System.out.println(n+" is the last prime factor");
            count*=2;
        }

        //System.out.println("number of divisors of "+tmp+" is "+count);
        return count;
    }

    private static long nchoosek(int n, int k) {

        long prod = 1;
        int j = 1;

        int st = Math.max(n-k, k)+1;
        int ed = Math.min(n-k, k);

        for(int i=st;i<=n;i++){
            for(;j<=ed;j++){
                if(prod%j==0)   prod/=j;
                else break;
            }
            prod*=i;
        }

        for(;j<=ed;j++){
            prod/=j;
        }

        return prod;
    }

    //related to extgcd problems
    private static boolean check() {
        //System.out.println(a+" "+b+" "+c1+" "+c2);
        if(n%ibgcd(a,b)!=0) {
           // System.out.println("not possible");
            return false;
        }

        extgcd(a,b);
        long gcd=0,m1=x,m2=y;
        gcd=d;
        m1*=(n/d);
        m2*=(n/d);
        a/=d;
        b/=d;

        double f1 = (m1/b);f1*=-1;
        double f2 = (m2/a);
        long le = (long) Math.ceil(f1);
        long re = (long) Math.floor(f2);
        if(le > re) return false;
        long cf=c1*b-c2*a;
        if(cf*le < cf*re){

            x = m1+b*le;
            y = m2-a*le;
        }else{
            x = m1+b*re;
            y = m2-a*re;
        }
        //System.out.println("upper and lower are "+le+" "+re);

        return true;
    }

    private static void extgcd(long a, long b) {

        if(b==0){
            x=1;y=0;d=a;return;
        }
        extgcd(b,a%b);
        long x1 = y;
        long y1 = x-(a/b)*y;
        x=x1;
        y=y1;
    }

    private static void floyd_cycle(int z, int I, int m, int x0) {

        int tor = func(z,I,m,x0);
        int har = func(z,I,m,tor); //one step ahead of tor
        //System.out.println("initial value for tor and har "+tor+" "+har);

        while(tor!=har){
            tor = func(z,I,m,tor);
            har = func(z,I,m,har);
            har = func(z,I,m,har);
            //System.out.println("tor and har "+tor+" "+har);
        }

        //at r-x%m now
        int x = 0;
        har = tor;
        tor = x0;

        while(har!=tor){

            tor = func(z,I,m,tor);
            har = func(z,I,m,har);
            x+=1;
            //System.out.println("findind x tor and har "+tor+" "+har);
        }

        //now at first reapting node
        int lam = 1;
        har = func(z,I,m,tor);

        while(har!=tor){
            har = func(z,I,m,har);
            lam+=1;
            //System.out.println("finding lam, tor and har "+tor+" "+har);
        }

       // return new Pair(z,lam);
    }

   private static int func(int z, int I, int m, int x0) {
        return ((z*x0)%m+I%m)%m;
    }

    private static void dfs(int a, int[][] d, int[] v,int[] p) {

        v[a] = 1;
        for(int i=0;i<v.length;i++){
            if(i!=a && d[i][a]!=0){
                if(v[i]==0){
                   // System.out.println("dfsing "+i);
                    p[i]=a;
                    dfs(i,d,v,p);
                }else if(p[a] != i && a<i){
                   // System.out.println(a+" and "+i+" causing cycle"+p[i]);
                    cycle=true;
                }
            }
        }

    }

    private static void dolve(int x, int[] a) {
        //find sors of x
        int cnt = 0;
        for(int i=2;i<=Math.sqrt(x);i=(i==2?3:i+2)){
            int pow = 0;
            while(x%i==0){
                x/=i;
                pow+=1;
            }
            if(pow!=0){
                for(int j=1;j<=pow;j++){
                    long f = (long) Math.pow(i, j);

                    if(f<a.length){
                        a[Integer.parseInt(String.valueOf(f))]=1;
                        //System.out.println("ading "+Integer.parseInt(String.valueOf(f)));
                    }

                }
            }
        }

        if(x!=1){
            //System.out.println("ading "+x);
            if(x<a.length)  a[x]=1;
        }
    }

    private static long search(long max, long tmp, long a, long b) {

        long lo = 0;
        long hi = max;

        while(lo < hi){

            long mid = (lo+hi)>>1;

            long k = mid*a;
            k/=b;
            if(k==tmp)  hi=mid;
            else    lo = mid+1;
        }

        return lo;
    }

    static class Node{

        int d=-1;
        long num;
        public Node(int a,long c){
            this.d = a;

            this.num = c;

        }
    }

    static class Edge{

        String d;
        int p;//ids of nodes
        int q;
        public Edge( String x1, int y1, int w){

            this.d = x1;
            this.p = y1;
            this.q = w;
        }
    }

    //simple sieve
    static boolean[] getPrimes(int n){

        boolean[] ret = new boolean[n+1];
        Arrays.fill(ret, true);

        ret[0] = ret[1] = false;

        for(int i=2;i*i <= n; i++){

            if(ret[i]){

                for(int j=i*i;j<=n;j+=i){

                    ret[j]=false;
                }
            }
        }

        return ret;
    }

    static long ibgcd(long a, long b){

        while(b > 0){
            long r = a%b;
            a=b;
            b=r;
        }
        return a;
    }

    //for extgcd
    static long x,y,d; //output and gdc
    static long c1,c2,a,b,n; // inputs
    //static boolean[] p = getPrimes(5000001);

    static class Pair{
        int a;
        int b;
        int w;
        public Pair(int a, int b, int w){
            this.a=a;
            this.b=b;
            this.w=w;
        }
    }

    static boolean cycle = false;
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new PrintWriter(System.out));

        boolean[] state = getPrimes(10000000);
        String[] _x = br.readLine().split(" ");

        int n = Integer.parseInt(_x[0]);

        int K = Integer.parseInt(_x[1]);

        if(K==0 || (n>>1) > K || n==1)  System.out.println(-1);
        else{
            int[] a = new int[n];
            for(int i=0;i<n;i++){
                a[i] = (i+1);
            }

            int x = K - (n>>1) + 1;
           // System.out.println("remaining "+x);

            int p = x;
            if(x > 1){
                for(int i=2;i<=state.length-1;i++){
                    if(state[i]&&x%i!=0 && x*i > 10000){
                        //System.out.println(x+" "+x*i);
                        p*=i;
                        break;
                    }
                }

                if(x > 100000){
                    a[0]=x;
                    a[1]=p;
                }else{
                    for(int i=0;i<n;i++){
                        if(a[i]==x){
                            if(a[i]%2==0){
                                a[i-1]=x;
                                a[i]=p;
                            }else{
                                a[i]=x;
                                a[i+1]=p;
                            }

                            break;
                        }
                    }
                }

            }

            for(int i=0;i<n;i++){
                bw.append(a[i]+" ");
            }
            bw.append("\n");
        }

        bw.close();
    }

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class MashmokhandNumbers {

	public static void main(String[] args) throws IOException {
		Init(System.in);

		int n = nextInt();
		int k = nextInt();

		if (n < 2 && k > 0) {
			System.out.println(-1);
			return;
		}

		if (n / 2 > k) {
			System.out.println(-1);
			return;
		}

		int numberOfCouples = n / 2;
		if (k == 1) {
			if (n == 2) {
				System.out.println("1 2");
			} else {
				System.out.println("1 2 3");
			}
			return;
		}
		if (k == 0 && n == 1) {

			System.out.println(1);
			return;
		}

		int diff = k - (numberOfCouples - 1);

		StringBuilder result = new StringBuilder();
		result.append(diff + " " + diff * 2 + " ");

		n -= 2;
		int i = 1;
		while (true) {
			if (i == diff || i == diff * 2 || i + 1 == diff
					|| i + 1 == 2 * diff) {
				i++;
				continue;
			}

			n -= 2;
			result.append(i + " " + (i + 1) + " ");
			i += 2;
			if (n < 2) {
				break;
			}
		}
		if (n == 1) {
			result.append(200000001);
		}

		System.out.println(result);
	}

	static BufferedReader reader;
	static StringTokenizer tokenizer;

	static void Init(InputStream input) {
		reader = new BufferedReader(new InputStreamReader(input));
		tokenizer = new StringTokenizer("");
	}

	static String next() throws IOException {
		while (!tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}

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

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


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class MashmokhandNumbers {

	public static void main(String[] args) throws IOException {
		Init(System.in);

		int n = nextInt();
		int k = nextInt();

		if (n < 2 && k > 0) {
			System.out.println(-1);
			return;
		}

		if (n / 2 > k) {
			System.out.println(-1);
			return;
		}

		int numberOfCouples = n / 2;
		if (k == 1) {
			if (n == 2) {
				System.out.println("1 2");
			} else {
				System.out.println("1 2 3");
			}
			return;
		}
		if (k == 0 && n == 1) {

			System.out.println(1);
			return;
		}

		int diff = k - (numberOfCouples - 1);

		StringBuilder result = new StringBuilder();
		result.append(diff + " " + diff * 2 + " ");

		n -= 2;
		int i = 1;
		while (true) {
			if (i == diff || i == diff * 2 || i + 1 == diff
					|| i + 1 == 2 * diff) {
				i++;
				continue;
			}

			n -= 2;
			result.append(i + " " + (i + 1) + " ");
			i += 2;
			if (n < 2) {
				break;
			}
		}
		if (n == 1) {
			result.append(i);
		}

		System.out.println(result);
	}

	static BufferedReader reader;
	static StringTokenizer tokenizer;

	static void Init(InputStream input) {
		reader = new BufferedReader(new InputStreamReader(input));
		tokenizer = new StringTokenizer("");
	}

	static String next() throws IOException {
		while (!tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}

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

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


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class MashmokhandNumbers {

	public static void main(String[] args) throws IOException {
		Init(System.in);

		int n = nextInt();
		int k = nextInt();

		if(n<2&&k>0){
			System.out.println(-1);
			return;
		}

		if (n / 2 > k) {
			System.out.println(-1);
			return;
		}

		int numberOfCouples = n / 2;
		if (k == 1) {
			if (n == 2) {
				System.out.println("1 2");
			} else {
				System.out.println("1 2 3");
			}
			return;
		}
		if (k == 0 && n == 1) {

			System.out.println(1);
		}

		int diff = k - (numberOfCouples - 1);

		StringBuilder result = new StringBuilder();
		result.append(diff + " " + diff * 2 + " ");

		n -= 2;
		int i = 1;
		while (true) {
			if (i == diff || i == diff * 2 || i + 1 == diff
					|| i + 1 == 2 * diff) {
				i++;
				continue;
			}

			n -= 2;
			result.append(i + " " + (i + 1) + " ");
			i += 2;
			if (n < 2) {
				break;
			}
		}
		if (n == 1) {
			result.append(i);
		}

		System.out.println(result);
	}

	static BufferedReader reader;
	static StringTokenizer tokenizer;

	static void Init(InputStream input) {
		reader = new BufferedReader(new InputStreamReader(input));
		tokenizer = new StringTokenizer("");
	}

	static String next() throws IOException {
		while (!tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}

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

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


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class MashmokhandNumbers {

	public static void main(String[] args) throws IOException {
		Init(System.in);

		int n = nextInt();
		int k = nextInt();

		if (n / 2 > k) {
			System.out.println(-1);
			return;
		}

		int numberOfCouples = n / 2;
		if (k == 1) {
			if (n == 2) {
				System.out.println("1 2");
			} else {
				System.out.println("1 2 3");
			}
			return;
		}
		if (k == 0 && n == 1) {

			System.out.println(1);
		}

		int diff = k - (numberOfCouples - 1);

		StringBuilder result = new StringBuilder();
		result.append(diff + " " + diff * 2 + " ");

		n -= 2;
		int i = 1;
		while (true) {
			if (i == diff || i == diff * 2 || i + 1 == diff
					|| i + 1 == 2 * diff) {
				i++;
				continue;
			}

			n -= 2;
			result.append(i + " " + (i + 1) + " ");
			i += 2;
			if (n < 2) {
				break;
			}
		}
		if (n == 1) {
			result.append(i);
		}

		System.out.println(result);
	}

	static BufferedReader reader;
	static StringTokenizer tokenizer;

	static void Init(InputStream input) {
		reader = new BufferedReader(new InputStreamReader(input));
		tokenizer = new StringTokenizer("");
	}

	static String next() throws IOException {
		while (!tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}

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

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


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class MashmokhandNumbers {

	public static void main(String[] args) throws IOException {
		Init(System.in);

		int n = nextInt();
		int k = nextInt();

		if (n < 2 && k > 0) {
			System.out.println(-1);
			return;
		}

		if (n / 2 > k) {
			System.out.println(-1);
			return;
		}

		int numberOfCouples = n / 2;
		if (k == 1) {
			if (n == 2) {
				System.out.println("1 2");
			} else {
				System.out.println("1 2 3");
			}
			return;
		}
		if (k == 0 && n == 1) {

			System.out.println(1);
			return;
		}

		int diff = k - (numberOfCouples - 1);

		StringBuilder result = new StringBuilder();
		result.append(diff + " " + diff * 2 + " ");

		n -= 2;
		int i = 1;

		while (true && n >= 2) {
			if (i == diff || i == diff * 2 || i + 1 == diff
					|| i + 1 == 2 * diff) {
				i++;
				continue;
			}

			n -= 2;
			result.append(i + " " + (i + 1) + " ");
			i += 2;
			if (n < 2) {
				break;
			}
		}
		if (n == 1) {
			result.append(200000001);
		}

		System.out.println(result);
	}

	static BufferedReader reader;
	static StringTokenizer tokenizer;

	static void Init(InputStream input) {
		reader = new BufferedReader(new InputStreamReader(input));
		tokenizer = new StringTokenizer("");
	}

	static String next() throws IOException {
		while (!tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}

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

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


import java.util.Scanner;

public class C {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        int k = sc.nextInt();

        int gcds = n / 2;

        if (n == 1 && k != 0) {
            System.out.println(-1);
            return;
        }

        int large = k - (gcds - 1);

        if (large <= 0) {
            System.out.println(-1);
            return;
        }

        StringBuilder sb = new StringBuilder();
        sb.append(large + " " + (large * 2));

        int rem = n - 2;
        for (int i = 1; rem > 0; i += 2) {
            if (i == large || i == large * 2) {
                continue;
            }
            if (i + 1 == large || i + 1 == large * 2) {
                continue;
            }
            rem -= 2;
            sb.append(" " + i + " " + (i + 1));
        }
        if (rem < 0) {
            for (int i = sb.length() - 1; i >= 0; i--) {
                if (sb.charAt(i) == ' ') {
                    sb.delete(i, sb.length());
                    break;
                }
            }
        }
        System.out.println(sb);
    }
}


import sun.print.resources.serviceui;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;
import java.util.regex.Pattern;

public class C {
    public static void main(String... args) throws IOException {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        in.close();
        int half = n / 2;
        if (n == 1) {
            if (k == 0)
                System.out.println(1);
            else
                System.out.println(-1);
            return;
        }
        if (k < half) {
            System.out.println(-1);
            return;
        }
        StringBuilder result = new StringBuilder();
        int diff = k - half + 1;
        int doublediff = 2 * diff;
        result.append(diff + " " + doublediff + " ");
        int next = 1;
        for (int i = 0; i < half - 1; i++) {
            while (next == diff || next == doublediff || (next + 1) == diff || (next + 1) == doublediff)
                next += 2;
            result.append(next + " " + (next+1)+ " ");
            next+=2;
        }
        while (next == diff || next == 2*diff)
            next += 2;
        if (n % 2 == 1)
            result.append(next);
        System.out.println(result);
    }

}


import sun.print.resources.serviceui;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;
import java.util.regex.Pattern;

public class C {
    public static void main(String... args) throws IOException {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        in.close();
        int half = n / 2;
        if (k < half) {
            System.out.println(-1);
            return;
        }
        StringBuilder result = new StringBuilder();
        int diff = k - half + 1;
        result.append(diff + " " + 2 * diff + " ");
        for (int i = 0; i < half - 1; i++) {
            result.append("2 3 ");
        }
        if (n % 2 == 1)
            result.append("1");
        System.out.println(result);
    }

}


import sun.print.resources.serviceui;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;
import java.util.regex.Pattern;

public class C {
    public static void main(String... args) throws IOException {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        in.close();
        int half = n / 2;
        if (k < half) {
            System.out.println(-1);
            return;
        }
        StringBuilder result = new StringBuilder();
        int diff = k - half + 1;
        int doublediff = 2 * diff;
        result.append(diff + " " + doublediff + " ");
        int next = 1;
        for (int i = 0; i < half - 1; i++) {
            while (next == diff || next == doublediff || (next + 1) == diff || (next + 1) == doublediff)
                next += 2;
            result.append(next + " " + (next+1)+ " ");
            next+=2;
        }
        while (next == diff || next == 2*diff)
            next += 2;
        if (n % 2 == 1)
            result.append(next);
        System.out.println(result);
    }

}


import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Vadim Semenov
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int counter = in.nextInt();
        int sum = in.nextInt();
        if (counter / 2 > sum) {
            out.println(-1);
            return;
        }
        if (counter == 1) {
            out.print(1);
            return;
        }
        int simple = (counter - 2) / 2;
        int first = sum - simple;
        int second = 2 * first;
        out.print(first + " " + second);
        int current = 1;
        int printed = 2;
        loop:
        while (printed < counter - 1) {
            for (int i = 0; i < 2; i++) {
                if (current + i == first || current + i == second) {
                    current++;
                    continue loop;
                }
            }
            out.print(" ");
            out.print(current++);
            out.print(" ");
            out.print(current++);
            printed += 2;
        }
        if (printed == counter - 1) {
            while (current == first || current == second) {
                current++;
            }
            out.print(" ");
            out.print(current);
        }
    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream inputStream) {
        reader = new BufferedReader(new InputStreamReader(inputStream));
    }

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

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return tokenizer.nextToken();
    }
}


import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Vadim Semenov
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int counter = in.nextInt();
        int sum = in.nextInt();
        if (counter / 2 > sum || (sum > 0 && counter == 1)) {
            out.println(-1);
            return;
        }
        if (counter == 1) {
            out.print(1);
            return;
        }
        int simple = (counter - 2) / 2;
        int first = sum - simple;
        int second = 2 * first;
        out.print(first + " " + second);
        int current = 1;
        int printed = 2;
        loop:
        while (printed < counter - 1) {
            for (int i = 0; i < 2; i++) {
                if (current + i == first || current + i == second) {
                    current++;
                    continue loop;
                }
            }
            out.print(" ");
            out.print(current++);
            out.print(" ");
            out.print(current++);
            printed += 2;
        }
        if (printed == counter - 1) {
            while (current == first || current == second) {
                current++;
            }
            out.print(" ");
            out.print(current);
        }
    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream inputStream) {
        reader = new BufferedReader(new InputStreamReader(inputStream));
    }

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

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return tokenizer.nextToken();
    }
}


import java.util.Scanner;

public class Round240_C_Mashmokh_and_Numbers {

	public static void main(String[] args) {
		Scanner x = new Scanner(System.in);
		long n = x.nextInt(), k = x.nextInt();
		if (n == 1){
			if (k == 0)
				System.out.println(12142);
			else {
				System.out.println(-1);
			}
		}
		else if (n / 2 > k)
			System.out.println(-1);
		else {
			long rest = (n / 2) - 1;
			long num = k - rest, num2 = num * 2;
			System.out.print(num + " " + (num2) + " ");
			for (int i = 0, j = 1; i < rest; i++, j += 2) {
				if (j != num && j + 1 != num && j != num2 && j + 1 != num2
						&& j != 100711433 && j + 1 != 100711433)
					System.out.print(j + " " + (j + 1) +" ");
				else
					i--;
			}
			if (n % 2 == 1) {
				System.out.println(100711433);
			}
		}

	}

}


import java.util.Scanner;

public class Round240_C_Mashmokh_and_Numbers {

	public static void main(String[] args) {
		Scanner x = new Scanner(System.in);
		int n = x.nextInt(), k = x.nextInt();
		if (n / 2 > k)
			System.out.println(-1);
		else {
			int rest = (n / 2) - 1;
			long num = k - rest, num2 = num * 2;
			System.out.print(num + " " + (num2) + " ");
			for (int i = 0, j = 1; i < rest; i++, j += 2) {
				if (j != num && j + 1 != num && j != num2 && j + 1 != num2
						&& j != 100711433 && j + 1 != 100711433)
					System.out.print(j + " " + (j + 1) +" ");
				else
					i--;
			}
			if (n % 2 == 1) {
				System.out.println(100711433);
			}
		}

	}

}


import java.util.Scanner;

public class Round240_C_Mashmokh_and_Numbers {

	public static void main(String[] args) {
		Scanner x = new Scanner(System.in);
		long n = x.nextInt(), k = x.nextInt();
		if (n / 2 > k || n == 1)
			System.out.println(-1);
		else {
			long rest = (n / 2) - 1;
			long num = k - rest, num2 = num * 2;
			System.out.print(num + " " + (num2) + " ");
			for (int i = 0, j = 1; i < rest; i++, j += 2) {
				if (j != num && j + 1 != num && j != num2 && j + 1 != num2
						&& j != 100711433 && j + 1 != 100711433)
					System.out.print(j + " " + (j + 1) +" ");
				else
					i--;
			}
			if (n % 2 == 1) {
				System.out.println(100711433);
			}
		}

	}

}


import java.util.Scanner;

public class C {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        int n=sc.nextInt();
        int k=sc.nextInt();

        if(n==1){
            if(k==0)
                System.out.println(1);
            else
                System.out.println(-1);
            System.exit(0);
        }

        if(k>=n/2){
            int p=(k-(n/2-1));

            System.out.print(p+" "+2*p+" ");

            int t=0;
            while(n-2>0){
                t++;
                if(t==p || t==p*2){
                    continue;
                }
                System.out.print(t+" ");
                n--;
            }
        }else
            System.out.println(-1);
    }
}


import java.util.Scanner;

public class C {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        int n=sc.nextInt();
        int k=sc.nextInt();

        if(n==1){
            System.out.println(-1);
            System.exit(0);
        }

        if(k>=n/2){
            int p=(k-(n/2-1));

            System.out.print(p+" "+2*p+" ");

            int t=0;
            while(n-2>0){
                t++;
                if(t==p || t==p*2){
                    continue;
                }
                System.out.print(t+" ");
                n--;
            }
        }else
            System.out.println(-1);
    }
}


import java.util.*;
import java.awt.Point;
import java.io.*;
import java.math.BigInteger;

public class C2
{
    FastScanner in;
    PrintWriter out;

    public static byte[] erastofen(int n)
    {
        byte mas[] = new byte[n];

        mas[0] = -1;

        for(int i = 2; i * i < n; i++)
        {
            if(mas[i] == 0)
            {
                for(int j = i * i; j < n; j += i)
                    mas[j] = -1;
            }
        }

        return mas;
    }

    public void solve() throws IOException
    {
        int n = in.nextInt();
        int k = in.nextInt();
        int m = n / 2;

        byte mas[] = erastofen(1500000);

        if (n == 1 && k == 0)
            out.print(1);
        else if (n == 1 || m > k)
            out.print(-1);
        else
        {
            int dif  = k - m + 1;

            if (dif > 1)
            {
                out.print(dif + " " + dif * 2 + " ");
                m--;
            }

            int kol    = m * 2 + n % 2;
            int pIndex = 1;

            for(int i = 0; i < kol; i++)
            {
                for(; ; pIndex++)
                {
                    if(mas[pIndex] == 0 && pIndex != dif)
                    {
                        out.print(pIndex++);
                        out.print(" ");
                        break;
                    }
                }

            }
        }
    }

    public void run()
    {
        try
        {
            in = new FastScanner();
            out = new PrintWriter(System.out);

            solve();

            out.close();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }

    class FastScanner
    {
        BufferedReader  br;
        StringTokenizer st;

        FastScanner()
        {

            br = new BufferedReader(new InputStreamReader(System.in));

        }

        FastScanner(File f)
        {
            try
            {
                br = new BufferedReader(new FileReader(f));
            }
            catch (FileNotFoundException e)
            {
                e.printStackTrace();
            }
        }

        String next()
        {
            while (st == null || !st.hasMoreTokens())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        int[] nextIntArray(int size)
        {
            int[] array = new int[size];

            for (int i = 0; i < size; i++)
            {
                array[i] = nextInt();
            }

            return array;
        }

        long[] nextLongArray(int size)
        {
            long[] array = new long[size];

            for (int i = 0; i < size; i++)
            {
                array[i] = nextLong();
            }

            return array;
        }

        BigInteger nextBigInteger()
        {
            return new BigInteger(next());
        }

        Point nextIntPoint()
        {
            int x = nextInt();
            int y = nextInt();
            return new Point(x, y);
        }

        Point[] nextIntPointArray(int size)
        {
            Point[] array = new Point[size];

            for (int index = 0; index < size; ++index)
            {
                array[index] = nextIntPoint();
            }

            return array;
        }

        List<Integer>[] readGraph(int vertexNumber, int edgeNumber, boolean undirected)
        {
            List<Integer>[] graph = new List[vertexNumber];

            for (int index = 0; index < vertexNumber; ++index)
            {
                graph[index] = new ArrayList<Integer>();
            }

            while (edgeNumber-- > 0)
            {
                int from = nextInt() - 1;
                int to = nextInt() - 1;

                graph[from].add(to);
                if (undirected)
                    graph[to].add(from);
            }

            return graph;
        }
    }

    public static void main(String[] arg)
    {
        new C2().run();
    }
}


import java.util.*;

/**
 * TODO: describe
 *
 * @author keks
 */
public class T240C {
    public static void main(String[] args) {
        final Scanner scanner = new Scanner(System.in);
        final long n = scanner.nextLong();
        long k = scanner.nextLong();
        long pairs = n / 2;
        final Map<Long, Long> ps = new HashMap<>();
        final Set<Object> used = new HashSet<>();
        scanner.nextLine();
        if (k / pairs == 0) {
            System.out.println(-1);
            return;
        }
        for (int i = 0; i < pairs; i++) {
            long p = k / (pairs - i) + (k % (pairs - i) != 0 ? 1 : 0);
            Long m = ps.get(p);
            if (m == null) {
                m = p;
            }
            while (used.contains(m) || used.contains(m + p)) m += p;
            System.out.print(m + " " + (m + p) + " ");
            used.add(m);
            used.add(m + p);
            k -= p;
            ps.put(p, m + 2L * p);
        }
        if (n % 2 != 0) {
            for (long i = 1; i < Long.MAX_VALUE; i++) {
                if (!used.contains(i)) {
                    System.out.println(i);
                    break;
                }
            }
        }
    }
}


import java.util.*;

/**
 * TODO: describe
 *
 * @author keks
 */
public class T240C {

    public static final int MAX = 1000000000;

    public static void main(String[] args) {
        final Scanner scanner = new Scanner(System.in);
        final long n = scanner.nextLong();
        long k = scanner.nextLong();
        long pairs = n / 2;
        if (pairs == 0 && k > 0) {
            System.out.println(-1);
            return;
        }
        final Map<Long, Long> ps = new HashMap<>();
        final Set<Long> used = new HashSet<>();
        scanner.nextLine();
        final ArrayList<Long> ans = new ArrayList<>();
        for (long i = 0; i < pairs; i++) {
            if (k / (pairs - i) == 0) {
                System.out.println(-1);
                return;
            }
            long p = k / (pairs - i) + (k % (pairs - i) != 0 ? 1 : 0);
            Long m = ps.get(p);
            if (m == null) {
                m = p;
            }
            while (used.contains(m) || used.contains(m + p)) m += p;
            if (m > MAX || (m + p) > MAX) {
                System.out.println(-1);
                return;
            }
            ans.add(m);
            ans.add(m + p);
            used.add(m);
            used.add(m + p);
            k -= p;
            ps.put(p, m + 2L * p);
        }
        for (Long an : ans) {
            System.out.print(an + " ");
        }

        if (n % 2 != 0) {
            for (long i = 1; i < Long.MAX_VALUE; i++) {
                if (!used.contains(i)) {
                    System.out.println(i);
                    break;
                }
            }
        }
    }
}


import java.util.*;

/**
 * TODO: describe
 *
 * @author keks
 */
public class T240C {
    public static void main(String[] args) {
        final Scanner scanner = new Scanner(System.in);
        final long n = scanner.nextLong();
        long k = scanner.nextLong();
        long pairs = n / 2;
        final Map<Long, Long> ps = new HashMap<>();
        final Set<Object> used = new HashSet<>();
        scanner.nextLine();
        for (int i = 0; i < pairs; i++) {
            long p = k / (pairs - i) + (k % (pairs - i) != 0 ? 1 : 0);
            if (k / (pairs - i) == 0) {
                System.out.println(-1);
                return;
            }
            Long m = ps.get(p);
            if (m == null) {
                m = p;
            }
            while (used.contains(m) || used.contains(m + p)) m += p;
            System.out.print(m + " " + (m + p) + " ");
            used.add(m);
            used.add(m + p);
            k -= p;
            ps.put(p, m + 2L * p);
        }
        if (n % 2 != 0) {
            for (long i = 1; i < Long.MAX_VALUE; i++) {
                if (!used.contains(i)) {
                    System.out.println(i);
                    break;
                }
            }
        }
    }
}


import java.util.*;

/**
 * TODO: describe
 *
 * @author keks
 */
public class T240C {

    public static final int MAX = 1000000000;

    public static void main(String[] args) {
        final Scanner scanner = new Scanner(System.in);
        final long n = scanner.nextLong();
        long k = scanner.nextLong();
        long pairs = n / 2;
        if (pairs == 0) {
            System.out.println(-1);
            return;
        }
        final Map<Long, Long> ps = new HashMap<>();
        final Set<Long> used = new HashSet<>();
        scanner.nextLine();
        final ArrayList<Long> ans = new ArrayList<>();
        for (long i = 0; i < pairs; i++) {
            if (k / (pairs - i) == 0) {
                System.out.println(-1);
                return;
            }
            long p = k / (pairs - i) + (k % (pairs - i) != 0 ? 1 : 0);
            Long m = ps.get(p);
            if (m == null) {
                m = p;
            }
            while (used.contains(m) || used.contains(m + p)) m += p;
            if (m > MAX || (m + p) > MAX) {
                System.out.println(-1);
                return;
            }
            ans.add(m);
            ans.add(m + p);
            used.add(m);
            used.add(m + p);
            k -= p;
            ps.put(p, m + 2L * p);
        }
        for (Long an : ans) {
            System.out.print(an + " ");
        }

        if (n % 2 != 0) {
            for (long i = 1; i < Long.MAX_VALUE; i++) {
                if (!used.contains(i)) {
                    System.out.println(i);
                    break;
                }
            }
        }
    }
}


import java.util.*;

/**
 * TODO: describe
 *
 * @author keks
 */
public class T240C {
    public static void main(String[] args) {
        final Scanner scanner = new Scanner(System.in);
        final long n = scanner.nextLong();
        long k = scanner.nextLong();
        long pairs = n / 2;
        final Map<Long, Long> ps = new HashMap<>();
        final Set<Object> used = new HashSet<>();
        scanner.nextLine();
        final ArrayList<Long> ans = new ArrayList<>();
        for (int i = 0; i < pairs; i++) {
            if (k / (pairs - i) == 0) {
                System.out.println(-1);
                return;
            }
            long p = k / (pairs - i) + (k % (pairs - i) != 0 ? 1 : 0);
            Long m = ps.get(p);
            if (m == null) {
                m = p;
            }
            while (used.contains(m) || used.contains(m + p)) m += p;
            ans.add(m);
            ans.add(m + p);
            used.add(m);
            used.add(m + p);
            k -= p;
            ps.put(p, m + 2L * p);
        }
        for (Long an : ans) {
            System.out.print(an + " ");
        }

        if (n % 2 != 0) {
            for (long i = 1; i < Long.MAX_VALUE; i++) {
                if (!used.contains(i)) {
                    System.out.println(i);
                    break;
                }
            }
        }
    }
}


import java.util.*;

/**
 * TODO: describe
 *
 * @author keks
 */
public class T240C {

    public static final int MAX = 1000000000;

    public static void main(String[] args) {
        final Scanner scanner = new Scanner(System.in);
        final long n = scanner.nextLong();
        long k = scanner.nextLong();
        long pairs = n / 2;
        final Map<Long, Long> ps = new HashMap<>();
        final Set<Long> used = new HashSet<>();
        scanner.nextLine();
        final ArrayList<Long> ans = new ArrayList<>();
        for (long i = 0; i < pairs; i++) {
            if (k / (pairs - i) == 0) {
                System.out.println(-1);
                return;
            }
            long p = k / (pairs - i) + (k % (pairs - i) != 0 ? 1 : 0);
            Long m = ps.get(p);
            if (m == null) {
                m = p;
            }
            while (used.contains(m) || used.contains(m + p)) m += p;
            if (m > MAX || (m + p) > MAX) {
                System.out.println(-1);
                return;
            }
            ans.add(m);
            ans.add(m + p);
            used.add(m);
            used.add(m + p);
            k -= p;
            ps.put(p, m + 2L * p);
        }
        for (Long an : ans) {
            System.out.print(an + " ");
        }

        if (n % 2 != 0) {
            for (long i = 1; i < Long.MAX_VALUE; i++) {
                if (!used.contains(i)) {
                    System.out.println(i);
                    break;
                }
            }
        }
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.StringTokenizer;

public class MashmokhandNumbers {

	public static void main(String[] args) throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		sc = new StringTokenizer("");
		ArrayList<Integer> p = new ArrayList<>();
		boolean[] v = new boolean[10000001];
		for (long i = 2; i * i < v.length; i++)
			if (!v[(int) i])
				for (long j = i * i; j < v.length; j += i)
					v[(int) j] = true;
		for (int i = 2; i < v.length; i++)
			if (!v[i])
				p.add(i);
		p.remove(p.size() - 1);
		int n = nxtInt();
		int k = nxtInt();
		if (n == 1)
			out.println(k == 0 ? "1" : "-1");
		else {
			int tot = n / 2;
			if (k < tot)
				out.println(-1);
			else {
				HashSet<Integer> hs = new HashSet<>();
				tot--;
				k -= tot;
				hs.add(k);
				hs.add(k * 2);
				out.print(k + " " + k * 2);
				int idx = 0;
				for (int i = 0; i < tot; i++) {
					int pow = (idx / p.size()) + 1;
					int ridx = idx % p.size();
					int a = (int) Math.pow(p.get(ridx), pow);
					int b = (int) Math.pow(p.get(ridx + 1), pow);
					if (!hs.contains(a) && !hs.contains(b)) {
						out.print(" " + a + " " + b);
						hs.add(a);
						hs.add(b);
					} else {
						i--;
					}
					idx += 2;
				}
				if (n % 2 == 1)
					out.print(" 1000000000");
				out.println();
			}
		}
		br.close();
		out.close();
	}

	static BufferedReader br;
	static StringTokenizer sc;
	static PrintWriter out;

	static String nxtTok() throws IOException {
		while (!sc.hasMoreTokens()) {
			String s = br.readLine();
			if (s == null)
				return null;
			sc = new StringTokenizer(s.trim());
		}
		return sc.nextToken();
	}

	static int nxtInt() throws IOException {
		return Integer.parseInt(nxtTok());
	}

	static long nxtLng() throws IOException {
		return Long.parseLong(nxtTok());
	}

	static double nxtDbl() throws IOException {
		return Double.parseDouble(nxtTok());
	}

	static int[] nxtIntArr(int n) throws IOException {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = nxtInt();
		return a;
	}

	static long[] nxtLngArr(int n) throws IOException {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nxtLng();
		return a;
	}

	static char[] nxtCharArr() throws IOException {
		return nxtTok().toCharArray();
	}
}


import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class MainC {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
	 public int gcd(int a, int b) {
	 		if (b == 0) return a;
			return gcd(b, a%b);
	 }

    public void solve(int testNumber, InputReader in, PrintWriter out) {
		  int n = in.nextInt();
		  int k = in.nextInt();

		  int[] base = new int[n];
		  for (int i = 0; i < base.length; i++) {
		  		base[i] = i + 1;
 		  }
		  int valid = n - (n % 2);
		  int points = valid / 2;

		  if (k == points) {
		  		for (int i = 0; i < base.length; i++) {
					out.print(base[i] + " ");
				}
		  		return;
		  }
		  if (k < points) {
		  		out.print("-1");
				return;
		  }
		  // k > points
		  int need = k - points;
		  int[] ans = new int[n];
		  for (int i = 0; i < ans.length; i++) {
		  		ans[i] = base[i];
		  }

		 while (need > 0)
			for (int i = valid - 1; i >= 0 && need > 0; i-= 2) {
				ans[i-1] += base[i-1];
				ans[i] += base[i];
				need--;
			}

		if (ans.length > 1){
			ans[ans.length - 1] = ans[ans.length - 2] + 1;
		}
	   for (int i = 0; i < ans.length; i++) {
			out.print(ans[i] + " ");
		}

    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

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

}


import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class MainC {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
	 public int gcd(int a, int b) {
	 		if (b == 0) return a;
			return gcd(b, a%b);
	 }

    public void solve(int testNumber, InputReader in, PrintWriter out) {
		  int n = in.nextInt();
		  int k = in.nextInt();

		  int[] ans = new int[n];
		  for (int i = 0; i < ans.length; i++) {
		  		ans[i] = i + 1;
 		  }
		  int valid = n - (n % 2);
		  int points = valid / 2;

		  if (k == points) {
		  		for (int i = 0; i < ans.length; i++) {
					out.print(ans[i] + " ");
				}
		  		return;
		  }
		  if (k < points) {
		  		out.print("-1");
				return;
		  }
		  // k > points
		  int need = k - points;
		  ans[valid - 2] *= (need + 1);
		  ans[valid - 1] *= (need + 1);
		if (ans.length > 1 && valid % 2 != 0){
			ans[ans.length - 1] = ans[ans.length - 2] + 1;
		}
	   for (int i = 0; i < ans.length; i++) {
			out.print(ans[i] + " ");
		}

    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

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

}


import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class MainC {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
	 public int gcd(int a, int b) {
	 		if (b == 0) return a;
			return gcd(b, a%b);
	 }

    public void solve(int testNumber, InputReader in, PrintWriter out) {
		  int n = in.nextInt();
		  int k = in.nextInt();

		  if (n == 1) {
			  if (k == 0) {
			  		out.println("1");
					return;
			  }
		  		out.println("-1");
				return;
		  }

		  int[] ans = new int[n];
		  for (int i = 0; i < ans.length; i++) {
		  		ans[i] = i + 1;
 		  }
		  int valid = n - (n % 2);
		  int points = valid / 2;

		  if (k == points) {
		  		for (int i = 0; i < ans.length; i++) {
					out.print(ans[i] + " ");
				}
		  		return;
		  }
		  if (k < points) {
		  		out.print("-1");
				return;
		  }
		  // k > points
		  int need = k - points;

		  ans[0] *= (need + 1);
		  ans[1] *= (need + 1);
		  for (int i = 2; i < ans.length; i++) {
		  	ans[i] = ans[i - 1] + 1;
		  }
		  //ans[valid - 2] *= (need + 1);
		  //ans[valid - 1] *= (need + 1);
		if (ans.length > 1 && valid % 2 != 0){
			ans[ans.length - 1] = ans[ans.length - 2] + 1;
		}
	   for (int i = 0; i < ans.length; i++) {
			out.print(ans[i] + " ");
		}

    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

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

}


import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class MainC {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
	 public int gcd(int a, int b) {
	 		if (b == 0) return a;
			return gcd(b, a%b);
	 }

    public void solve(int testNumber, InputReader in, PrintWriter out) {
		  int n = in.nextInt();
		  int k = in.nextInt();

		  if (n == 1) {
			  if (k == 0) {
			  		out.println("1");
					return;
			  }
		  		out.println("-1");
				return;
		  }

		  int[] ans = new int[n];
		  for (int i = 0; i < ans.length; i++) {
		  		ans[i] = i + 1;
 		  }
		  int valid = n - (n % 2);
		  int points = valid / 2;

		  if (k == points) {
		  		for (int i = 0; i < ans.length; i++) {
					out.print(ans[i] + " ");
				}
		  		return;
		  }
		  if (k < points) {
		  		out.print("-1");
				return;
		  }
		  // k > points
		  int need = k - points;
		  ans[valid - 2] *= (need + 1);
		  ans[valid - 1] *= (need + 1);
		if (ans.length > 1 && valid % 2 != 0){
			ans[ans.length - 1] = ans[ans.length - 2] + 1;
		}
	   for (int i = 0; i < ans.length; i++) {
			out.print(ans[i] + " ");
		}

    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

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

}


import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class MainC {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
	 public int gcd(int a, int b) {
	 		if (b == 0) return a;
			return gcd(b, a%b);
	 }

    public void solve(int testNumber, InputReader in, PrintWriter out) {
		  int n = in.nextInt();
		  int k = in.nextInt();

		  int[] ans = new int[n];
		  for (int i = 0; i < ans.length; i++) {
		  		ans[i] = i + 1;
 		  }
		  int valid = n - (n % 2);
		  int points = valid / 2;

		  if (k == points) {
		  		for (int i = 0; i < ans.length; i++) {
					out.print(ans[i] + " ");
				}
		  		return;
		  }
		  if (k < points) {
		  		out.print("-1");
				return;
		  }
		  // k > points
		  int need = k - points;
		  ans[valid - 2] *= (need + 1);
		  ans[valid - 1] *= (need + 1);
		if (ans.length > 1){
			ans[ans.length - 1] = ans[ans.length - 2] + 1;
		}
	   for (int i = 0; i < ans.length; i++) {
			out.print(ans[i] + " ");
		}

    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

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

}


//package codeforces;

import java.io.*;
import java.nio.charset.CharsetEncoder;
import java.util.*;

public class C {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter writer = new PrintWriter(System.out);
    StringTokenizer stringTokenizer;

    C() throws IOException {
//        reader = new BufferedReader(new FileReader("bridges.in"));
//        writer = new PrintWriter(new FileWriter("bridges.out"));
    }

    String next() throws IOException {
        while (stringTokenizer == null || !stringTokenizer.hasMoreTokens()) {
            stringTokenizer = new StringTokenizer(reader.readLine());
        }
        return stringTokenizer.nextToken();
    }

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

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

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

    final int MOD = 1000 * 1000 * 1000 + 7;

    int sum(int a, int b) {
        a += b;
        return a >= MOD ? a - MOD : a;
    }

    int product(int a, int b) {
        return (int) (1l * a * b % MOD);
    }

    int pow(int x, int k) {
        int result = 1;
        while (k > 0) {
            if (k % 2 == 1) {
                result = product(result, x);
            }
            x = product(x, x);
            k /= 2;
        }
        return result;
    }

    int inv(int x) {
        return pow(x, MOD - 2);
    }

    void solve() throws IOException {
        int n = nextInt(), k = nextInt();
        if(n == 1) {
            writer.println(k == 0 ? 1 : -1);
            writer.close();
            return;
        }
        int[] a = new int[n];
        for(int i = 1; i <= n; i++) {
            a[i - 1] = i;
        }
        int s = n / 2 - 1;
        int r = k - s;
        if(r <= 0) {
            writer.println(-1);
        } else {
            int last = n - 1;
            int p = last - 1;
            if(p % 2 == 1) {
                p--;
            }
            int j = 1;
            while(j * r <= p) {
                j++;
            }
            a[p] = j * r;
            a[p + 1] = (j + 1) * r;
            if(last > p + 1) {
                a[last] = a[p + 1] + 1;
            }
            for (int x : a) {
                writer.print(x + " ");
            }
        }
        writer.close();
    }

    public static void main(String[] args) throws IOException {
        new C().solve();
    }
}


//package codeforces;

import java.io.*;
import java.nio.charset.CharsetEncoder;
import java.util.*;

public class C {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter writer = new PrintWriter(System.out);
    StringTokenizer stringTokenizer;

    C() throws IOException {
//        reader = new BufferedReader(new FileReader("bridges.in"));
//        writer = new PrintWriter(new FileWriter("bridges.out"));
    }

    String next() throws IOException {
        while (stringTokenizer == null || !stringTokenizer.hasMoreTokens()) {
            stringTokenizer = new StringTokenizer(reader.readLine());
        }
        return stringTokenizer.nextToken();
    }

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

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

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

    final int MOD = 1000 * 1000 * 1000 + 7;

    int sum(int a, int b) {
        a += b;
        return a >= MOD ? a - MOD : a;
    }

    int product(int a, int b) {
        return (int) (1l * a * b % MOD);
    }

    int pow(int x, int k) {
        int result = 1;
        while (k > 0) {
            if (k % 2 == 1) {
                result = product(result, x);
            }
            x = product(x, x);
            k /= 2;
        }
        return result;
    }

    int inv(int x) {
        return pow(x, MOD - 2);
    }

    void solve() throws IOException {
        int n = nextInt(), k = nextInt();
        int[] a = new int[n];
        for(int i = 1; i <= n; i++) {
            a[i - 1] = i;
        }
        int s = n / 2 - 1;
        int r = k - s;
        if(r <= 0) {
            writer.println(-1);
        } else {
            int last = n - 1;
            int p = last - 1;
            if(p % 2 == 1) {
                p--;
            }
            int j = 1;
            while(j * r <= p) {
                j++;
            }
            a[p] = j * r;
            a[p + 1] = (j + 1) * r;
            if(last > p + 1) {
                a[last] = a[p + 1] + 1;
            }
            for (int x : a) {
                writer.print(x + " ");
            }
        }
        writer.close();
    }

    public static void main(String[] args) throws IOException {
        new C().solve();
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {

  private void solve() throws IOException {
    int n = ni();
    int k = ni();

    if (k < n / 2) {
      prln(-1);
      return;
    }

    if (n == 1) {
      if (k == 0) pr(1); else pr(-1);
      return;
    }

    while (n > 3) {
      n -= 2;
      pr("1 1 ");
      k--;
    }

    pr(k + " " + k);
    if (n == 3)
      pr(" " + 1);
  }

  public static void main(String ... args) throws IOException { new C().run(); }

  private PrintWriter pw;
  private BufferedReader br;
  private StringTokenizer st;

  private void run() throws IOException {
    pw = new PrintWriter(System.out);
    br = new BufferedReader(new InputStreamReader(System.in));
    solve();
    br.close();
    pw.close();
  }

  private void pr(Object o) { pw.print(o); }
  private void prln(Object o) {pw.println(o);}
  private void prln() {pw.println();}

  private long nl() throws IOException { return Long.parseLong(nt());	}

  private double nd() throws IOException  { return Double.parseDouble(nt()); }

  private int ni()throws IOException  { return Integer.parseInt(nt()); }

  private String nt() throws IOException {
    if (st == null || !st.hasMoreTokens())
      st = new StringTokenizer(br.readLine());
    return st.nextToken();
  }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {

  int primes[] = new int[100010];

  boolean isPrime(int cd) {
    int bd = (int)(Math.sqrt(cd));
    for (int i = 2; i <= bd; ++i) {
      if (cd % i == 0)
        return false;
    }
    return true;
  }

  private void solve() throws IOException {
    int n = ni();
    int k = ni();
    int cd = 2;
    primes[0] = 1;
    for (int i = 1; i < 100010; ++i) {
      while (!isPrime(cd)) cd++;
      primes[i] = cd;
      cd++;
    }

    if (k < n / 2) {
      prln(-1);
      return;
    }

    if (n == 1) {
      if (k == 0) pr(1); else pr(-1);
      return;
    }

    int pi = 0;
    while (n > 3) {
      n -= 2;
      pr(primes[pi] + " " + primes[pi + 1] + " ");
      pi += 2;
      k--;
    }

    if (k == 1) {
      pr(primes[pi] + " " + primes[pi + 1]);
      pi += 2;
    } else {
      pr(k*2 + " " + k*3);
    }
    if (n == 3)
      pr(" " + primes[pi]);
  }

  public static void main(String ... args) throws IOException { new C().run(); }

  private PrintWriter pw;
  private BufferedReader br;
  private StringTokenizer st;

  private void run() throws IOException {
    pw = new PrintWriter(System.out);
    br = new BufferedReader(new InputStreamReader(System.in));
    solve();
    br.close();
    pw.close();
  }

  private void pr(Object o) { pw.print(o); }
  private void prln(Object o) {pw.println(o);}
  private void prln() {pw.println();}

  private long nl() throws IOException { return Long.parseLong(nt());	}

  private double nd() throws IOException  { return Double.parseDouble(nt()); }

  private int ni()throws IOException  { return Integer.parseInt(nt()); }

  private String nt() throws IOException {
    if (st == null || !st.hasMoreTokens())
      st = new StringTokenizer(br.readLine());
    return st.nextToken();
  }
}


import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;

public class lolat1 {

	public static void main(String[] args) {
		// TODO Auto-generated constructor stub
		Scanner in = new Scanner(System.in);
			int n = in.nextInt();
			int k = in.nextInt();

			if (n > 2 * k + 1 || (k == 0 && n > 1) || (k > 0 && n < 1)) {
				System.out.println(-1);
				return;
			}
			int[] ans = new int[n];
			int num = (n - n % 2) / 2;
			num = k - num + 1;
			for (int i = 0, j = 6000000; i < n; ++j, i++) {
				ans[i] = j;
			}
			if (num != 1) {
				ans[0] = num;
				if (n > 1)
					ans[1] = (num * num);
			}
			System.out.print(ans[0]);
			for (int i = 1; i < n; i++) {
				System.out.print(" " + ans[i]);
			}
	}

}


import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;

public class lolat1 {

	public static void main(String[] args) {
		// TODO Auto-generated constructor stub
		Scanner in = new Scanner(System.in);
			int n = in.nextInt();
			int k = in.nextInt();

			if (n > 2 * k + 1 || (k == 0 && n > 1) || (k > 0 && n <= 1)) {
				System.out.println(-1);
				return;
			}
			long [] ans = new long[n];
			long num = (n - n % 2) / 2;
			num = k - num + 1;
			for (long i = 0, j = 3000000; i < n; ++j, i++) {
				ans[(int)i] = j;
			}
			if (num != 1) {
				ans[0] = num;
				if (n > 1)
					ans[1] = (num * 2);
			}
			System.out.print(ans[0]);
			for (int i = 1; i < n; i++) {
				System.out.print(" " + ans[i]);
			}
	}

}


import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class lolat1 {
	private static Queue<Integer> primes;
	private static HashMap<Integer, Integer> a;

	public static void main(String[] args) {
		// TODO Auto-generated constructor stub
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int k = in.nextInt();

		if (n > 2 * k + 1) {
			System.out.println(-1);
			return;
		}
		int[] ans = new int[n];
		int num = (n - n % 2) / 2;
		num = k - num + 1;
		if (num != 1)
			System.out.print(num + " " + num * num);
		else
			System.out.print(1 + " " + 2);
		for (int i = 2, j = 6000000; i < n; ++j, i++) {
			System.out.print(" " + j);
		}
	}

}


import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;

public class lolat1 {

	public static void main(String[] args) {
		// TODO Auto-generated constructor stub
		Scanner in = new Scanner(System.in);
			int n = in.nextInt();
			int k = in.nextInt();

			if (n > 2 * k + 1 || (k == 0 && n > 1) || (k > 0 && n <= 1)) {
				System.out.println(-1);
				return;
			}
			int[] ans = new int[n];
			int num = (n - n % 2) / 2;
			num = k - num + 1;
			for (int i = 0, j = 6000000; i < n; ++j, i++) {
				ans[i] = j;
			}
			if (num != 1) {
				ans[0] = num;
				if (n > 1)
					ans[1] = (num * num);
			}
			System.out.print(ans[0]);
			for (int i = 1; i < n; i++) {
				System.out.print(" " + ans[i]);
			}
	}

}


import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;

public class lolat1 {

	public static void main(String[] args) {
		// TODO Auto-generated constructor stub
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int k = in.nextInt();

		if (n > 2 * k + 1 || n == 1) {
			System.out.println(-1);
			return;
		}
		int[] ans = new int[n];
		int num = (n - n % 2) / 2;
		num = k - num + 1;
		if (num != 1)
			System.out.print(num + " " + num * num);
		else
			System.out.print(1 + " " + 2);
		for (int i = 2, j = 6000000; i < n; ++j, i++) {
			System.out.print(" " + j);
		}
	}

}


import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class lolat1 {
	private static Queue<Integer> primes;
	private static HashMap<Integer, Integer> a;
	public static void main(String[] args) {
		// TODO Auto-generated constructor stub
		Sieve();
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int k = in.nextInt();

		if(n>2*k+1){System.out.println(-1);return;}
		int [] ans = new int [n];
		int num = (n - n%2)/2;
		num = k - num+1;
		System.out.print(num + " " + num*num);
		for(int i = 2 ; i < n ; i ++){
			System.out.print(" " + primes.poll());
		}

	}

	private static void Sieve(){
		boolean isPrime []= new boolean[10000000];
		Arrays.fill(isPrime, true);
		isPrime[0]=false;
		isPrime[1]=false;
		isPrime[2]=true;
		primes = new LinkedList<Integer>();
		for(int i =2;i<isPrime.length;i++){
			if(isPrime[i]){
				for(int j=i*2;j<isPrime.length;j+=i){
					isPrime[j]=false;
				}
			}
		}
		for(int i=0;i<isPrime.length;i++){
			if(isPrime[i]){
				primes.add(i);
			}
		}
	}

}


import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;

public class lolat1 {

	public static void main(String[] args) {
		// TODO Auto-generated constructor stub
		Scanner in = new Scanner(System.in);
			int n = in.nextInt();
			int k = in.nextInt();

			if (n > 2 * k + 1 || (k == 0 && n > 1) || (k > 0 && n <= 1)) {
				System.out.println(-1);
				return;
			}
			long[] ans = new long[n];
			int num = (n - n % 2) / 2;
			num = k - num + 1;
			for (long i = 0, j = 3000000; i < n; ++j, i++) {
				ans[(int)i] = j;
			}
			if (num != 1) {
				ans[0] = num;
				if (n > 1)
					ans[1] = (num * num);
			}
			System.out.print(ans[0]);
			for (int i = 1; i < n; i++) {
				System.out.print(" " + ans[i]);
			}
	}

}


import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;

public class lolat1 {

	public static void main(String[] args) {
		// TODO Auto-generated constructor stub
		Scanner in = new Scanner(System.in);
			int n = in.nextInt();
			int k = in.nextInt();

			if (n > 2 * k + 1 || (k == 0 && n > 1) || (k > 0 && n <= 1)) {
				System.out.println(-1);
				return;
			}
			long[] ans = new long[n];
			int num = (n - n % 2) / 2;
			num = k - num + 1;
			for (long i = 0, j = 30000; i < n; ++j, i++) {
				ans[(int)i] = j;
			}
			if (num != 1) {
				ans[0] = num;
				if (n > 1)
					ans[1] = (num * num);
			}
			System.out.print(ans[0]);
			for (int i = 1; i < n; i++) {
				System.out.print(" " + ans[i]);
			}
	}

}


import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;

public class lolat1 {

	public static void main(String[] args) {
		// TODO Auto-generated constructor stub
		Scanner in = new Scanner(System.in);
			int n = in.nextInt();
			int k = in.nextInt();

			if (n > 2 * k + 1 || (k == 0 && n > 1) || (k > 0 && n <= 1)) {
				System.out.println(-1);
				return;
			}
			long [] ans = new long[n];
			long num = (n - n % 2) / 2;
			num = k - num + 1;
			for (long i = 0, j = 30000; i < n; ++j, i++) {
				ans[(int)i] = j;
			}
			if (num != 1) {
				ans[0] = num;
				if (n > 1)
					ans[1] = (num * 2);
			}
			System.out.print(ans[0]);
			for (int i = 1; i < n; i++) {
				System.out.print(" " + ans[i]);
			}
	}

}


import java.io.*;
import java.util.*;

public class Main implements Runnable {
  final boolean isFileIO = false;
  BufferedReader in;
  PrintWriter out;
  StringTokenizer st = new StringTokenizer("");
  String delim = " ";

  public static void main(String[] args) {
    new Thread(null, new Main(), "", 268435456).start();
  }

  public void run() {
    try {
      initIO();
      solve();
      out.close();
    } catch(Exception e) {
      e.printStackTrace(System.err);
      System.exit(-1);
    }
  }

  public void initIO() throws IOException {
    if(!isFileIO) {
      in = new BufferedReader(new InputStreamReader(System.in));
      out = new PrintWriter(System.out);
    } else {
      in = new BufferedReader(new FileReader("input.txt"));
      out = new PrintWriter("output.txt");
    }
  }

  String nextToken() throws IOException {
    if(!st.hasMoreTokens()) {
      st = new StringTokenizer(in.readLine());
    }
    return st.nextToken(delim);
  }

  String readLine() throws IOException {
    return in.readLine();
  }

  int nextInt() throws IOException {
   return Integer.parseInt(nextToken());
  }

  long nextLong() throws IOException {
    return Long.parseLong(nextToken());
  }

  double nextDouble() throws IOException {
    return Double.parseDouble(nextToken());
  }

  void solve() throws IOException {
    int n = nextInt(); int k = nextInt();
    int m = 10000000;
    boolean[] prime = new boolean[m];
    int cnt = 0;
    for(int i = 2; i * i < m; i++) {
      if(!prime[i]) {
        for(int j = i * i; j < m; j += i) {
          prime[j] = true;
        }
      }
    }
    if(k < n / 2) {
      out.println(-1);
      return;
    } else {
      if(n % 2 == 0) {
        out.print((k - (n - 2) / 2) * 2 + " " + 3 * (k - (n - 2) / 2) + " ");
      } else {
        out.print((k - (n - 3) / 2) * 2 + " " + 3 * (k - (n - 3) / 2 ) + " ");
      }
      for(int i = 4, z = n - 2; i < m && z > 0; i++) {
        if(!prime[i]) {
          out.print(i + " ");
          z--;
        }
      }
    }
  }
}


import java.io.*;
import java.util.*;

public class Main implements Runnable {
  final boolean isFileIO = false;
  BufferedReader in;
  PrintWriter out;
  StringTokenizer st = new StringTokenizer("");
  String delim = " ";

  public static void main(String[] args) {
    new Thread(null, new Main(), "", 268435456).start();
  }

  public void run() {
    try {
      initIO();
      solve();
      out.close();
    } catch(Exception e) {
      e.printStackTrace(System.err);
      System.exit(-1);
    }
  }

  public void initIO() throws IOException {
    if(!isFileIO) {
      in = new BufferedReader(new InputStreamReader(System.in));
      out = new PrintWriter(System.out);
    } else {
      in = new BufferedReader(new FileReader("input.txt"));
      out = new PrintWriter("output.txt");
    }
  }

  String nextToken() throws IOException {
    if(!st.hasMoreTokens()) {
      st = new StringTokenizer(in.readLine());
    }
    return st.nextToken(delim);
  }

  String readLine() throws IOException {
    return in.readLine();
  }

  int nextInt() throws IOException {
   return Integer.parseInt(nextToken());
  }

  long nextLong() throws IOException {
    return Long.parseLong(nextToken());
  }

  double nextDouble() throws IOException {
    return Double.parseDouble(nextToken());
  }

  void solve() throws IOException {
    int n = nextInt(); int k = nextInt();
    int m = 10000000;
    boolean[] prime = new boolean[m];
    int cnt = 0;
    for(int i = 2; i * i < m; i++) {
      if(!prime[i]) {
        for(int j = i * i; j < m; j += i) {
          prime[j] = true;
        }
      }
    }
    if(n == 1) {
      if(k != 0)
        out.println(-1);
      else
        out.println(1);
      return;
    }
    if(k < n / 2) {
      out.println(-1);
      return;
    } else {
      if(n % 2 == 0) {
        out.print((k - (n - 2) / 2) * 2 + " " + 3 * (k - (n - 2) / 2) + " ");
      } else {
        out.print((k - (n - 3) / 2) * 2 + " " + 3 * (k - (n - 3) / 2 ) + " ");
      }
      for(int i = 4, z = n - 2; i < m && z > 0; i++) {
        if(!prime[i]) {
          out.print(i + " ");
          z--;
        }
      }
    }
  }
}


import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.Set;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.HashSet;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Mahmoud Aladdin <aladdin3>
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    public void solve(int testNumber, InputReader jin, OutputWriter jout) {
        int n = jin.int32();
        int k = jin.int32();

        if(k == 0) {
            if(n == 1) {
                jout.println(1);
            } else {
                jout.println(-1);
            }
        } else {
            if(k < (n >> 1)) {
                jout.println(-1);
            } else {
                Set<Integer> arr = new HashSet<Integer>();
                StringBuffer out = new StringBuffer();
                int up = k - (n >> 1);
                for(int b = 1; b <= (n >> 1); b++) {
                    if(up % b > 0) continue;
                    int a = (up / b) + 1;
                    if((2L * a * b) > (int)1e9) continue;
                    if(a <= 0) continue;
                    out.setLength(0); arr.clear();
                    for(int i = 1; i <= (b * 2); i++) {
                        out.append(a * i);
                        out.append(' ');
                        arr.add(a * i);
                    }
                    int c = ((n >> 1) - b);
                    int start = -1;
                    for(int i = 0; i < c; i += 2) {
                        start += 2;
                        if(arr.contains(start) || arr.contains(start + 1)) {
                            i -= 2;
                            continue;
                        }
                        out.append(start);
                        out.append(' ');
                        out.append(start + 1);
                        out.append(' ');
                        arr.add(start);
                        arr.add(start + 1);
                    }
                    if(n % 2 == 1) {
                        start = 1;
                        while(arr.contains(start)) start++;
                        out.append(start);
                    }
                    jout.println(out);
                    break;
                }
                if(out.length() == 0) {
                    jout.println(-1);
                }
            }
        }
    }
}

class InputReader {
    private static final int bufferMaxLength = 1024;
    private InputStream in;
    private byte[] buffer;
    private int currentBufferSize;
    private int currentBufferTop;
    private static final String tokenizers = " \t\r\f\n";

    public InputReader(InputStream stream) {
        this.in = stream;
        buffer = new byte[bufferMaxLength];
        currentBufferSize = 0;
        currentBufferTop = 0;
    }

    private boolean refill() {
        try {
            this.currentBufferSize = this.in.read(this.buffer);
            this.currentBufferTop = 0;
        } catch(Exception e) {}
        return this.currentBufferSize > 0;
    }

    private Byte readChar() {
        if(currentBufferTop < currentBufferSize) {
            return this.buffer[this.currentBufferTop++];
        } else {
            if(!this.refill()) {
                return null;
            } else {
                return readChar();
            }
        }
    }

    public String token()  {
        StringBuffer tok = new StringBuffer();
        Byte first;
        while((first = readChar()) != null && (tokenizers.indexOf((char) first.byteValue()) != -1));
        if(first == null) return null;
        tok.append((char)first.byteValue());
        while((first = readChar()) != null && (tokenizers.indexOf((char) first.byteValue()) == -1)) {
            tok.append((char)first.byteValue());
        }
        return tok.toString();
    }

    public Integer int32() throws NumberFormatException {
        String tok = token();
        return tok == null? null : Integer.parseInt(tok);
    }

    }

class OutputWriter {
    private final int bufferMaxOut = 1024;
    private PrintWriter out;
    private StringBuilder output;
    private boolean forceFlush = false;

    public OutputWriter(OutputStream outStream) {
        out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outStream)));
        output = new StringBuilder(2 * bufferMaxOut);
    }

    public OutputWriter(Writer writer) {
        forceFlush = true;
        out = new PrintWriter(writer);
        output = new StringBuilder(2 * bufferMaxOut);
    }

    private void autoFlush() {
        if(forceFlush || output.length() >= bufferMaxOut) {
            flush();
        }
    }

    public void print(Object... tokens) {
        for(int i = 0; i < tokens.length; i++) {
            if(i != 0) output.append(' ');
            output.append(tokens[i]);
        }
        autoFlush();
    }

    public void println(Object... tokens) {
        print(tokens);
        output.append('\n');
        autoFlush();
    }

    public void flush() {
        out.print(output);
        output.setLength(0);
    }

    public void close() {
        flush();
        out.close();
    }
}