#include<stdio.h>

int main(void)
{
    int i,j,k,m,n,c,f;
    char a[2000][2000];
    scanf("%d%d",&n,&m);

    for(i=0;i<n;i++)
        scanf("%s",a[i]);
    c=0;
    for(i=0;i<m;i++)
    {
        f=0;
        for(j=0;j<n;j++)
        {
            if(a[j][i]=='1') f++;

        }
        //printf("In col %d f=%d\n",i,f);
        if(f==1) c++;
    }
    //printf("c=%d\n",c);
    if(c<=n) printf("YES");
    else printf("NO");

    return 0;

}


#include<stdio.h>

int main(void)
{
    int i,j,k,m,n,c,f;
    char a[2000][2000];
    scanf("%d%d",&n,&m);

    for(i=0;i<n;i++)
        scanf("%s",a[i]);
    c=0;
    for(i=0;i<m;i++)
    {
        f=0;
        for(j=0;j<n;j++)
        {
            if(a[j][i]=='1') f++;

        }
        //printf("In col %d f=%d\n",i,f);
        if(f==1) c++;
    }
    //printf("c=%d\n",c);
    if(c<n) printf("YES");
    else printf("NO");

    return 0;

}


#include<stdio.h>

int main(void)
{
    int i,j,k,m,n,c,f;
    char a[2000][2000];
    scanf("%d%d",&n,&m);
//Here c means how many lamps can be on by just one switch

    for(i=0;i<n;i++)
        scanf("%s",a[i]);
    c=0;
    for(i=0;i<m;i++)
    {
        f=0;
        for(j=0;j<n;j++)
        {
            if(a[j][i]=='1') f++;

        }
        //printf("In col %d f=%d\n",i,f);
        if(f==1) c++;
    }
    //printf("c=%d\n",c);
    if(c<n) printf("YES");
    else printf("NO");

    return 0;

}


#include<stdio.h>
int main(void)
{
    int i,j,k,c,m,n,need=0;
    char a[2000][2000];
    scanf("%d%d",&n,&m);
    for(i=0;i<n;i++)
        scanf("%s",a[i]);
    for(i=0;i<n;i++)
    {
        for(j=0;j<m;j++)
        {
            /*printf("\na[%d][%d]=%c",i,j,a[i][j]);*/
            c=0;
            if(a[i][j]=='1')
            {
                /*printf("Hello line %d\n",i+1);*/

                for(k=0;k<n;k++)
                    if(a[k][j]=='0')
                    {
                        c++;
                        /*printf("now i=%d and c=%d\n",i,c);*/
                    }

            }
            if(c==(n-1))
            {
                need++;
                /*printf("need is line %d\n",i+1);*/
                break;
            }
        }

    }
    if(n==need) printf("NO");
    else printf("YES");

    return 0;
}
/*wrong on test 12
why for i==1 printf is not output

*/


#include<stdio.h>
int main(void)
{
    int i,j,k,c,m,n,need=0;
    char a[2000][2000];
    int s[2000];
    scanf("%d%d",&n,&m);
    for(i=0;i<n;i++)
        scanf("%s",a[i]);
    int ans=0;
    for(i=0;i<n;i++)
    {
        int flag=0;
        for(j=0;j<m;j++)
        {
            if(a[i][j]=='1'&&s[j]==1)
            {
                flag=1;
            }
        }
        if(flag==0)
        {
            ans=1;
            break;
        }
    }
    if(ans==0)
    {
        printf("NO");
    }
    else
    {
        printf("YES");
    }
    return 0;
}


#include <stdio.h>

int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	char a[n][m];
	for(int i=0;i<n;i++)
	scanf("%s",a[i]);
	int perma[m],leave;
	memset(perma,0,m*sizeof(int));
	for(leave=0;leave<n;leave++)
	{
		memset(perma,0,m*sizeof(int));
		for(int j=0;j<n;j++)
		{
			if(j!=leave)
			{
				for(int k=0;k<m;k++)
				{
					if(a[j][k]=='1')
					{
						perma[k]=1;
					}
				}
			}
		}
		int j;
		for(j=0;j<m;j++)
		{
			if(perma[j]==0)
			break;
		}
		if(j==m)
		break;
	}
	if(leave==n)
	printf("NO");
	else
	printf("YES");
	return 0;
}


#include <stdio.h>
int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	char a[n][m];
	for(int i=0;i<n;i++)
	scanf("%s",a[i]);
	int perma[m],leave;
	memset(perma,0,m*sizeof(int));
	for(int i=0;i<n;i++)
	{
	    for(int j=0;j<m;j++)
	    if(a[i][j]=='1')
	    perma[j]++;
	}
	int i;
	for(i=0;i<n;i++)
	{
	    int flag=1;
	    for(int j=0;j<m;j++)
	    {
	        if(a[i][j]=='1')
	        {
	            if(perma[j]-1<=0)
	            {
	                flag=0;
	                break;
	            }
	        }
	    }
	    if(flag==1)
	    break;
	}
	if(i!=n)
	printf("YES");
	else
	printf("NO");
	return 0;
}


#include<stdio.h>

int main() {
    int n,m;
    scanf("%d%d",&n,&m);
    char a[n][2001];
    int i,j;
    for(i=0;i<n;i++) {
        scanf("%s",a[i]);
    }
    int f=0,k;
    for(i=0;i<n;i++) {
        int c=0;
        for(j=0;j<m;j++) {
            for(k=0;k<n;k++) {
                    if(k!=i) {
                    if(a[k][j]=='1') {
                        c++;
                        break;
                    }
                    }
            }
        }
        if(c==m) {
            f=1;
            break;
        }
    }
    if(f==1)
        printf("YES");
    else
        printf("NO");
    return 0;
}


#include <stdio.h>

int main()
{
	int n,m;
	char a[2000][2000];
	int csum[2000];
	int tmp;
	int i,j;
	int sum;
	char line[2001];

	scanf("%d %d",&n,&m);

	for (i=0;i<n;i++)
	{
		scanf("%s",line);
		for (j=0;j<m;j++)
			a[i][j] = line[j]-'0';
	}

	for (j=0;j<m;j++)
	{
		csum[j] = 0;
		for (i=0;i<n;i++)
			csum[j]+=a[i][j];
	}

	tmp = 1;
	for (j=0;j<m;j++)
	{
	 	if (csum[j]<2) { tmp = 0; break; }
	}

	if (tmp==1)
	{
		printf("YES\n");
		return 0;
	}

	for (i=0;i<n;i++)
	{
		tmp = 1;
		for (j=0;j<m;j++)
		{
			if (a[i][j]==1 && csum[j]<2)
				tmp = 0;
		}
		if (tmp==1)
		{
			printf("YES\n");
			return 0;
		}
	}
	printf("NO\n");

	return 0;

}


#include<stdio.h>
#define N 2001
int main()
{
	char affected_switchs[N][N];int tot[N]={0},n,m,i,i1,redundant=0,p;
	char temp[N];
	scanf("%d%d",&n,&m);
	for(i1=0;i1<n;i1++)
	{
		scanf("%s",temp);
		for(i=0;i<m;i++)
		{
			affected_switchs[i1][i]=temp[i];
			tot[i]+=affected_switchs[i1][i]-'0';
		}
	}
	// for(i=0;i<m;i++)
		// printf("%d",tot[i]);
	// printf("\n");
	//p=contribute
	for(i1=0;i1<n;i1++)
	{
		p=0;
		for(i=0;i<m;i++)
		{
			if(tot[i]==1&&affected_switchs[i1][i]=='1')
			p=1;
		}
		if(!p)
			redundant=1;
	}
	if(redundant)
		printf("YES\n");
	else
		printf("NO\n");
	return 0;
}


#include<stdio.h>
#define N 2001
int main()
{
	char affected_switchs[N][N];int tot[N]={0},n,m,i,i1,redundant=0,p;
	char temp[N];
	scanf("%d%d",&n,&m);
	for(i1=0;i1<n;i1++)
	{
		scanf("%s",temp);
		for(i=0;i<m;i++)
		{
			affected_switchs[i1][i]=temp[i];
			tot[i]+=affected_switchs[i1][i]-'0';
		}
	}
	for(i=0;i<m;i++)
		printf("%d",tot[i]);
	printf("\n");
	//p=contribute
	for(i1=0;i1<n;i1++)
	{
		p=0;
		for(i=0;i<m;i++)
		{
			if(tot[i]==affected_switchs[i1][i]-'0')
			p=1;
		}
		if(!p)
			redundant=1;
	}
	if(redundant)
		printf("YES\n");
	else
		printf("NO\n");
	return 0;
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.concurrent.PriorityBlockingQueue;

import javax.swing.ComboBoxEditor;

public class aa {
	public static class node {
		int ch;
		int index;

		node(int ch, int index) {
			this.ch = ch;
			this.index = index;
		}
	}

	public static ArrayList<Integer> prime = new ArrayList();
	public static boolean check[] = new boolean[10000000];

	public static void solve() {
		prime.add(1);
		for (int i = 2; i < 10000000; i++) {
			if (!check[i]) {
				prime.add(i);
				for (long j = (long) i * (long) i; j < 10000000; j += i) {
					check[(int) j] = true;
				}
			}
		}
	}

	public static void main(String[] args) throws IOException {
		solve();

	//	 System.out.println(prime.size());
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		StringBuilder q = new StringBuilder();
		String y[] = in.readLine().split(" ");
		int n = Integer.parseInt(y[0]);
		int k = Integer.parseInt(y[1]);
		if (n / 2 > k||(n==1&&k!=0))
			q.append(-1);
		else {
			int d = n / 2;
			int ans = k - d + 1;
			int loop = n;
			if (ans > 1) {
				if(n>1)
				q.append((ans * 2) + " " + (ans * 3) + " ");
				else
					q.append(ans*2);
				loop -= 2;
			}

			for (int i = 0; i < loop; i++) {
				q.append(prime.get(i) + " ");

			}

		}
		System.out.println(q);

		out.close();

	}
}


import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

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

class TaskC {
	public void solve(int testNumber, Scanner in, PrintWriter out) {
		int n = in.nextInt();
		int k = in.nextInt();
		if (n == 1) {
			if (k == 0) {
				out.print(1);
			} else {
				out.print(-1);
			}
			return;
		}
		int count = n / 2;
		if (k < count) {
			out.print(-1);
			return;
		}
		for (int i = 0; i < count - 1; ++i) {
			out.print("1 1 ");
			--k;
		}
		out.print(k + " " + k);
		if (n % 2 == 1) out.print(" " + 1);
	}
}


import java.util.List;
import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.io.InputStream;

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

class TaskC {
	public void solve(int testNumber, Scanner in, PrintWriter out) {
		int n = in.nextInt();
		int k = in.nextInt();
		List<Integer> primeList = makePrimeList(1500000);
		if (n == 1) {
			if (k == 0) {
				out.print(1);
			} else {
				out.print(-1);
			}
			return;
		}
		int count = n / 2;
		if (k < count) {
			out.print(-1);
			return;
		}
		int ptr = 0;
		for (int i = 0; i < count - 1; ++i) {
			out.print(primeList.get(ptr++) + " " + primeList.get(ptr++) + " ");
			--k;
		}
		if (k == 1) {
			out.print(primeList.get(ptr++) + " " + primeList.get(ptr++) + " ");
		} else {
			out.print(k * 2 + " " + k * 3 + " ");
		}
		if (n % 2 == 1) out.print(primeList.get(ptr++));
	}

	public static List<Integer> makePrimeList(int limit) {
		boolean[] isPrime = new boolean[limit + 1];
		Arrays.fill(isPrime, true);
		isPrime[0] = isPrime[1] = false;
		for (int i = 0; i <= limit; i++)
			if (isPrime[i] != false) {
				for (int j = i + i; j <= limit; j += i) isPrime[j] = false;
			}
		List<Integer> primeList = new ArrayList<Integer>();
		for (int i = 0; i < isPrime.length; ++i)
			if (isPrime[i])
				primeList.add(i);
		return primeList;
	}
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
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 n = in.readInt();
        int k = in.readInt();
        if(n / 2 > k){
            out.println(-1);
            return;
        }
        int p2 = 3;
        for (int i = 0, p1 = 2; i < n/2 - 1; i++, p1+=2, p2 += 2) {
            out.print(p1 +" " + p2 + " ");
        }
        int high = (int)(Math.log(p2) / Math.log(2) + 1);
        int high3 = (int)(Math.log(p2) / Math.log(3) + 1);
        if (n != 1) out.print((k - n / 2 + 1)*(1 << high) + " " + (k - n / 2 + 1) * ((int)Math.pow(3, high)));
        if (n % 2 == 1) out.println(" " + 1);
    }
}

class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
                this.stream = stream;
        }

        public int read() {
                if (numChars == -1)
                        throw new InputMismatchException();
                if (curChar >= numChars) {
                        curChar = 0;
                        try {
                                numChars = stream.read(buf);
                        } catch (IOException e) {
                                throw new InputMismatchException();
                        }
                        if (numChars <= 0)
                                return -1;
                }
                return buf[curChar++];
        }

        public int readInt() {
                int c = read();
                while (isSpaceChar(c))
                        c = read();
                int sgn = 1;
                if (c == '-') {
                        sgn = -1;
                        c = read();
                }
                int res = 0;
                do {
                        if (c < '0' || c > '9')
                                throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                } while (!isSpaceChar(c));
                return res * sgn;
        }

        public boolean isSpaceChar(int c) {
                if (filter != null)
                        return filter.isSpaceChar(c);
                return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
                public boolean isSpaceChar(int ch);
        }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
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 n = in.readInt();
        int k = in.readInt();
        if(n / 2 > k){
            out.println(-1);
            return;
        }
        int p2 = 3;
        for (int i = 0, p1 = 2; i < n/2 - 1; i++, p1+=2, p2 += 2) {
            out.print(p1 +" " + p2 + " ");
        }
        int high = (int)(Math.log(p2) / Math.log(2) + 1);
        int high3 = (int)(Math.log(p2) / Math.log(3) + 1);
        if (n != 1) out.print((k - n / 2 + 1)*(1 << high) + " " + (k - n / 2 + 1) * ((int)Math.pow(3, high3)));
        if (n % 2 == 1) out.println(" " + 1);
    }
}

class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
                this.stream = stream;
        }

        public int read() {
                if (numChars == -1)
                        throw new InputMismatchException();
                if (curChar >= numChars) {
                        curChar = 0;
                        try {
                                numChars = stream.read(buf);
                        } catch (IOException e) {
                                throw new InputMismatchException();
                        }
                        if (numChars <= 0)
                                return -1;
                }
                return buf[curChar++];
        }

        public int readInt() {
                int c = read();
                while (isSpaceChar(c))
                        c = read();
                int sgn = 1;
                if (c == '-') {
                        sgn = -1;
                        c = read();
                }
                int res = 0;
                do {
                        if (c < '0' || c > '9')
                                throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                } while (!isSpaceChar(c));
                return res * sgn;
        }

        public boolean isSpaceChar(int c) {
                if (filter != null)
                        return filter.isSpaceChar(c);
                return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
                public boolean isSpaceChar(int ch);
        }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
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 n = in.readInt();
        int k = in.readInt();
        if(n / 2 > k || n == 1 && k != 0){
            out.println(-1);
            return;
        }
        int p2 = 3;
        for (int i = 0, p1 = 2; i < n/2 - 1; i++, p1+=2, p2 += 2) {
            out.print(p1 +" " + p2 + " ");
        }
        int high = (int)(5e8 - (5e8 % (k - n /2 + 1)));
        if (n != 1) out.print(high + " " + (high + (k - n/2 + 1)));
        if (n % 2 == 1) out.println(" " + 1);
    }
}

class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
                this.stream = stream;
        }

        public int read() {
                if (numChars == -1)
                        throw new InputMismatchException();
                if (curChar >= numChars) {
                        curChar = 0;
                        try {
                                numChars = stream.read(buf);
                        } catch (IOException e) {
                                throw new InputMismatchException();
                        }
                        if (numChars <= 0)
                                return -1;
                }
                return buf[curChar++];
        }

        public int readInt() {
                int c = read();
                while (isSpaceChar(c))
                        c = read();
                int sgn = 1;
                if (c == '-') {
                        sgn = -1;
                        c = read();
                }
                int res = 0;
                do {
                        if (c < '0' || c > '9')
                                throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                } while (!isSpaceChar(c));
                return res * sgn;
        }

        public boolean isSpaceChar(int c) {
                if (filter != null)
                        return filter.isSpaceChar(c);
                return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
                public boolean isSpaceChar(int ch);
        }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
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 n = in.readInt();
        int k = in.readInt();
        if(n / 2 > k){
            out.println(-1);
            return;
        }
        for (int i = 0; i < n/2 - 1; i++) {
            out.print("2 3 ");
        }
        if (n != 1) out.print((k - n/2 + 1) + " " + (k - n/2 + 1));
        if (n % 2 == 1) out.println(" " + 2);
    }
}

class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
                this.stream = stream;
        }

        public int read() {
                if (numChars == -1)
                        throw new InputMismatchException();
                if (curChar >= numChars) {
                        curChar = 0;
                        try {
                                numChars = stream.read(buf);
                        } catch (IOException e) {
                                throw new InputMismatchException();
                        }
                        if (numChars <= 0)
                                return -1;
                }
                return buf[curChar++];
        }

        public int readInt() {
                int c = read();
                while (isSpaceChar(c))
                        c = read();
                int sgn = 1;
                if (c == '-') {
                        sgn = -1;
                        c = read();
                }
                int res = 0;
                do {
                        if (c < '0' || c > '9')
                                throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                } while (!isSpaceChar(c));
                return res * sgn;
        }

        public boolean isSpaceChar(int c) {
                if (filter != null)
                        return filter.isSpaceChar(c);
                return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
                public boolean isSpaceChar(int ch);
        }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
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 n = in.readInt();
        int k = in.readInt();
        if(n / 2 > k || n == 1 && k != 0){
            out.println(-1);
            return;
        }
        int p2 = 3;
        for (int i = 0, p1 = 2; i < n/2 - 1; i++, p1+=2, p2 += 2) {
            out.print(p1 +" " + p2 + " ");
        }
        int high = (int)(Math.log(p2) / Math.log(2) + 1);
        int high3 = (int)(Math.log(p2) / Math.log(3) + 1);
        if (n != 1) out.print((k - n / 2 + 1)*(1 << high) + " " + (k - n / 2 + 1) * ((int)Math.pow(3, high3)));
        if (n % 2 == 1) out.println(" " + 1);
    }
}

class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
                this.stream = stream;
        }

        public int read() {
                if (numChars == -1)
                        throw new InputMismatchException();
                if (curChar >= numChars) {
                        curChar = 0;
                        try {
                                numChars = stream.read(buf);
                        } catch (IOException e) {
                                throw new InputMismatchException();
                        }
                        if (numChars <= 0)
                                return -1;
                }
                return buf[curChar++];
        }

        public int readInt() {
                int c = read();
                while (isSpaceChar(c))
                        c = read();
                int sgn = 1;
                if (c == '-') {
                        sgn = -1;
                        c = read();
                }
                int res = 0;
                do {
                        if (c < '0' || c > '9')
                                throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                } while (!isSpaceChar(c));
                return res * sgn;
        }

        public boolean isSpaceChar(int c) {
                if (filter != null)
                        return filter.isSpaceChar(c);
                return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
                public boolean isSpaceChar(int ch);
        }
}


import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.InputMismatchException;

public class A {
	static final long most = (long)1e9;
	public static void main(String[] args) {
		FasterScanner sc = new FasterScanner();
		PrintWriter out = new PrintWriter(System.out);

		PrimeSieve PS = new PrimeSieve(1300000);
		int N = sc.nextInt();
		int K = sc.nextInt();
		long[] array = new long[N];
		int pos = 2;
		for(int a=0;a<N;a++){
			while(!PS.isPrime(pos))pos++;
			array[a]=pos;
			pos++;
		}
		int cur = N/2;
		for(int a=0;a<N;a+=2){
			if(a+1>=N)break;
			int factor = 1;
			while(factor+1*array[a+1]<=most&&cur+factor<=K){
				factor++;
			}
			array[a]*=factor;
			array[a+1]*=factor;
			cur+=factor-1;
		}
		if(cur==K)
		for(int a=0;a<N;a++){
			out.print(array[a]+" ");
		}
		else out.print("-1");

		out.close();
	}

	static class PrimeSieve {
		int[] prime;
		PrimeSieve(int N){
			prime = new int[N+1];
			prime[1] = -1;
			int M = (int)Math.sqrt(N);
			for(int a=2;a<=M;a++)
				if(prime[a]==0)
					for(int b=a*a;b<=N;b+=a)
						if(prime[b]==0)
							prime[b]=a;
		}
		boolean isPrime(int N){
			return prime[N]==0;
		}
	}

	static class FasterScanner{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public FasterScanner(){
			stream = System.in;
			//stream = new FileInputStream(new File("dec.in"));

		}
		int read(){
			if(numChars==-1)
				throw new InputMismatchException();
			if(curChar>=numChars){
				curChar = 0;
				try{
					numChars = stream.read(buf);
				} catch (IOException e){
					throw new InputMismatchException();
				}
				if(numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		boolean isSpaceChar(int c){
			return c==' '||c=='\n'||c=='\r'||c=='\t'||c==-1;
		}
		boolean isEndline(int c){
			return c=='\n'||c=='\r'||c==-1;
		}
		int nextInt(){
			return Integer.parseInt(next());
		}
		long nextLong(){
			return Long.parseLong(next());
		}
		double nextDouble(){
			return Double.parseDouble(next());
		}
		String next(){
			int c = read();
			while(isSpaceChar(c))
				c=read();
			StringBuilder res = new StringBuilder();
			do{
				res.appendCodePoint(c);
				c=read();
			} while(!isSpaceChar(c));
			return res.toString();
		}
		String nextLine(){
			int c = read();
			while(isEndline(c))
				c=read();
			StringBuilder res = new StringBuilder();
			do{
				res.appendCodePoint(c);
				c = read();
			}while(!isEndline(c));
			return res.toString();
		}

	}
}


import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.InputMismatchException;

public class A {
	static final long most = (long)1e9;
	public static void main(String[] args) {
		FasterScanner sc = new FasterScanner();
		PrintWriter out = new PrintWriter(System.out);

		PrimeSieve PS = new PrimeSieve(1300000);
		int N = sc.nextInt();
		int K = sc.nextInt();
		long[] array = new long[N];
		int pos = 2;
		for(int a=0;a<N;a++){
			while(!PS.isPrime(pos))pos++;
			array[a]=pos;
			pos++;
		}
		int cur = N/2;
		for(int a=0;a<N;a+=2){
			if(a+1>=N)break;
			int factor = 1;
			while(factor+1*array[a+1]<=most&&cur+factor<=K){
				factor++;
			}
			array[a]*=factor;
			array[a+1]*=factor;
			cur+=factor-1;
		}
		if(cur==K)
		for(int a=0;a<N;a++){
			out.print(array[a]+" ");
		}
		else out.print("-1 ");

		out.close();
	}

	static class PrimeSieve {
		int[] prime;
		PrimeSieve(int N){
			prime = new int[N+1];
			prime[1] = -1;
			int M = (int)Math.sqrt(N);
			for(int a=2;a<=M;a++)
				if(prime[a]==0)
					for(int b=a*a;b<=N;b+=a)
						if(prime[b]==0)
							prime[b]=a;
		}
		boolean isPrime(int N){
			return prime[N]==0;
		}
	}

	static class FasterScanner{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public FasterScanner(){
			stream = System.in;
			//stream = new FileInputStream(new File("dec.in"));

		}
		int read(){
			if(numChars==-1)
				throw new InputMismatchException();
			if(curChar>=numChars){
				curChar = 0;
				try{
					numChars = stream.read(buf);
				} catch (IOException e){
					throw new InputMismatchException();
				}
				if(numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		boolean isSpaceChar(int c){
			return c==' '||c=='\n'||c=='\r'||c=='\t'||c==-1;
		}
		boolean isEndline(int c){
			return c=='\n'||c=='\r'||c==-1;
		}
		int nextInt(){
			return Integer.parseInt(next());
		}
		long nextLong(){
			return Long.parseLong(next());
		}
		double nextDouble(){
			return Double.parseDouble(next());
		}
		String next(){
			int c = read();
			while(isSpaceChar(c))
				c=read();
			StringBuilder res = new StringBuilder();
			do{
				res.appendCodePoint(c);
				c=read();
			} while(!isSpaceChar(c));
			return res.toString();
		}
		String nextLine(){
			int c = read();
			while(isEndline(c))
				c=read();
			StringBuilder res = new StringBuilder();
			do{
				res.appendCodePoint(c);
				c = read();
			}while(!isEndline(c));
			return res.toString();
		}

	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.PriorityQueue;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class CopyOfCopyOfSolution {
    private static Integer val = 40;

    /**
     * #235 Div2 Problem D
     * #href: http://codeforces.com/contest/401/problem/D
     *
     * @param args
     * @throws NumberFormatException
     * @throws IOException
     */
    public static void main(final String[] args) throws NumberFormatException, IOException {
        final InputStream inputStream = System.in;
        final OutputStream outputStream = System.out;
        final InputReader in = new InputReader(inputStream);
        final PrintWriter out = new PrintWriter(outputStream);
        final int n = in.nextInt();
        int k = in.nextInt();
        if (k < (n / 2)) {
            out.println(-1);
        } else {
            if (k == 0) {
                out.println("1");
            } else if (n == 1) {
                out.println("-1");
            } else {
                k -= ((n / 2) - 1);
                out.print(k + " ");
                out.print((2 * k) + " ");
                int w = 1;
                int i = 2;
                for (; i < n;) {
                    while ((w == k) || (w == (2 * k)) || ((w + 1) == k) || ((w + 1) == (2 * k))) {
                        w++;
                    }
                    out.print(w++ + " ");
                    i++;
                    if (i < n) {
                        out.print(w++ + " ");
                    }
                    i++;
                }
                if (i < n) {
                    out.print(w++ + " ");
                }
                out.println();
            }
        }
        out.close();
    }

    private static Tree construct(final long[] a, final int from, final int to) {
        final Tree tree = new Tree();
        tree.from = 0;
        tree.to = a.length;
        if ((to - from) == 1) {
            tree.sum = a[from];
        } else {
            tree.left = construct(a, from, (from + to) / 2);
            tree.right = construct(a, (from + to) / 2, to);
            tree.sum = tree.left.sum + tree.right.sum;
        }
        return tree;
    }

    private static class Tree {
        int from;
        int to;
        long sum;
        Tree left;
        Tree right;

        public void update(final int index, final long diff) {
            if (diff == 0) {
                return;
            }
            if ((index >= this.from) && (index < this.to)) {
                this.sum += diff;
                if ((this.right != null)) {
                    this.right.update(index, diff);
                }
                if ((this.left != null)) {
                    this.left.update(index, diff);
                }
            }
        }
    }

    private static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(final InputStream stream) {
            this.reader = new BufferedReader(new InputStreamReader(stream));
            this.tokenizer = null;
        }

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

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

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

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

    }
}


import java.util.*;
public class man240{
 public static void main(String[] args)
    {
        Scanner obj = new Scanner(System.in);
        String nm=obj.nextLine();
        String[] arr_num = nm.split(" ");
        int n=Integer.parseInt(arr_num[0]);
        int k=Integer.parseInt(arr_num[1]);
        //System.out.println(n/2);
		if(k<n/2||n==1)
		System.out.println(-1);
		else{
			int m=(n/2);
			if(k==m)
			{
				for(int i=1;i<=n;i++)
				System.out.print(i+" ");
			}
			else
			{
				int no=k-m+1;
				System.out.print(no+" "+2*no+" ");
				for(int i=1,j=(2*no+1);i<=n-2;i++,j++)
				System.out.print(j+" ");
			}
		}
	}
}


import java.util.*;
public class man240{
 public static void main(String[] args)
    {
        Scanner obj = new Scanner(System.in);
        String nm=obj.nextLine();
        String[] arr_num = nm.split(" ");
        int n=Integer.parseInt(arr_num[0]);
        int k=Integer.parseInt(arr_num[1]);
        //System.out.println(n/2);
		if(k<n/2||(n==1&&k>=1))
		System.out.println(-1);
		else{
			int m=(n/2);
			if(k==m)
			{
				for(int i=1;i<=n;i++)
				System.out.print(i+" ");
			}
			else
			{
				int no=k-m+1;
				System.out.print(no+" "+2*no+" ");
				for(int i=1,j=(2*no+1);i<=n-2;i++,j++)
				System.out.print(j+" ");
			}
		}
	}
}


import java.util.Scanner;

public class cf {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        if (k < n / 2 || (n == 1 && k > 0) || (n > 1 && k == 0)) {
            System.out.println(-1);
        } else if (n == 1) {
            System.out.println(42);
        } else if (k == 0) {
            System.out.println(42);
        } else {
            int x = k - (n - 2) / 2;
            System.out.printf("%d ", x);
            System.out.printf("%d ", x * 2);
            for (int i = 2; i < n; i++) {
                System.out.printf("%d ", x * 2 + i);
            }
        }
    }
}


import java.util.Scanner;

public class cf {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        if (k < n / 2) {
            System.out.println(-1);
        } else {
            int x = k - (n - 2) / 2;
            System.out.printf("%d ", x);
            System.out.printf("%d ", x * 2);
            for (int i = 2; i < n; i++) {
                System.out.printf("%d ", x * 2 + i);
            }
        }

    }
}


import java.util.Scanner;

public class cf {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        if (k < n / 2 || n == 1) {
            System.out.println(-1);
        } else {
            int x = k - (n - 2) / 2;
            System.out.printf("%d ", x);
            System.out.printf("%d ", x * 2);
            for (int i = 2; i < n; i++) {
                System.out.printf("%d ", x * 2 + i);
            }
        }

    }
}


//package R240;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.TreeSet;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Map;
import java.util.PriorityQueue;
public class q3{
    public static void main(String args[]){
        FasterScanner s=new FasterScanner();
        PrintWriter out=new PrintWriter(System.out);
        long n=s.nextLong();
        long k=s.nextLong();
        long a[]=new long[(int) n];
        if(n==1){
            if(k>0){
                System.out.println(-1);
            }
            else{
                System.out.println(1);
            }
            return;
        }
        if(k<n/2){
            System.out.println(-1);
            return;
        }
        long h=n/2;
        long e=k-h+1;

        a[0]=e;
        a[1]=2*a[0];

        for(int i=2;i<n;i++)
            a[i] = a[i - 1] + 1;
        for(int i=0;i<n;i++){
            out.print(a[i]+" ");
        }
        out.close();
    }

    public static class FasterScanner {
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public int read() {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = System.in.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndOfLine(c));
            return res.toString();
        }

        public String nextString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

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

        public long[] nextLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }
            return arr;
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }
    }
}


import java.util.*;
import java.io.*;
public class a {
public static void main(String[] args) throws IOException
{
    input.init(System.in);
    PrintWriter out = new PrintWriter(System.out);

    int n = input.nextInt(), k = input.nextInt();
    int count = n/2;
    if(k<count || (n == 1 && k > 0)) out.println(-1);
    else
    {
        int prev = 0;
        for(int i = 0; i<count-1; i++)
        {
            out.print((2*i+1)+" "+(2*i+2)+" ");
            prev = 2*i+2;
        }
        if(n>1)
        {
            int secondLast = (k-count+1), x = secondLast;
            //out.println(secondLast);
            while(x<= prev) x+= secondLast;
            out.print(x+" "+(x+secondLast)+" ");
        }
        if(n%2 == 1) out.print(1000000000);
    }

    out.close();
}
public static class input {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                     new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }

    /** get next word */
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                   reader.readLine() );
        }
        return tokenizer.nextToken();
    }

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

    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }
}
}


import java.io.InputStream;
import java.util.Scanner;

public class CF240CDev2 {

	String solve(int n, int k) {
		if (n / 2 > k)
			return "-1";
		else if (n == 1 && k == 0)
			return "1";
		else if (n / 2 == 0 && k > 0)
			return "-1";

		int ret[] = new int[n];
		int rem = k - n / 2;
		ret[0] = rem + 1;
		ret[1] = ret[0] << 1;
		for (int i = 2; i < n; i++) {
			ret[i] = ret[i - 1] + 1;
		}

		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < ret.length; i++) {
			sb.append(ret[i]);
			if (i != ret.length - 1)
				sb.append(" ");
		}
		return sb.toString();
	}

	String solve(InputStream in) {
		Scanner sc = new Scanner(in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		return solve(n, k);
	}

	public static void main(String[] args) {
		System.out.println(new CF240CDev2().solve(System.in));
	}

}


import java.io.InputStream;
import java.util.Scanner;

public class CF240CDev2 {

	String solve(int n, int k) {
		if (n / 2 > k)
			return "-1";
		else if (n == 1 && k == 0)
			return "1";
		else if (n / 2 == 0 && k > 0)
			return "-1";

		int ret[] = new int[n];
		int rem = k - n / 2;
		ret[0] = ret[1] = rem + 1;
		for (int i = 2; i < n; i++) {
			ret[i] = 1;
		}

		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < ret.length; i++) {
			sb.append(ret[i]);
			if (i != ret.length-1) sb.append(" ");
		}
		return sb.toString();
	}

	String solve(InputStream in) {
		Scanner sc = new Scanner(in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		return solve(n, k);
	}

	public static void main(String[] args) {
		System.out.println(new CF240CDev2().solve(System.in));
	}

}


import java.io.InputStream;
import java.util.Scanner;

public class CF240CDev2 {

	String solve(int n, int k) {
		if (n / 2 > k)
			return "-1";
		else if (n == 1 && k == 0)
			return "1";
		else if (n / 2 == 0 && k > 0)
			return "-1";

		int ret[] = new int[n];
		int rem = k - n / 2;
		ret[0] = ret[1] = rem + 1;
		for (int i = 2; i < n; i++) {
			ret[i] = 1;
		}

		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < ret.length; i++) {
			sb.append(ret[i]).append(" ");
		}
		return sb.toString();
	}

	String solve(InputStream in) {
		Scanner sc = new Scanner(in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		return solve(n, k);
	}

	public static void main(String[] args) {
		System.out.println(new CF240CDev2().solve(System.in));
	}

}


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(n==1 && K==0)   System.out.println("1");
        else 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 > n){
                        //System.out.println(x+" "+x*i);
                        p*=i;
                        break;
                    }
                }

                if(x > n){
                    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(n==1 && K==0)   System.out.println("1");
        else 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.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(n==1 && K==0)   System.out.println("1");
        else 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(x*i > n){
                       // System.out.println(i+" "+x+" "+x*i);
                        p*=i;
                        break;
                    }
                }

                if(x > n){
                    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();
    }

}