It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh. 

In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.

Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way. 

Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.

Input

The first line of input contains two space-separated integers n, k (1 ≤ n ≤ 105; 0 ≤ k ≤ 108).

Output

If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).

Examples

Input

5 2


Output

1 2 3 4 5


Input

5 3

Output

2 4 3 7 1

Input

7 2


Output

-1

Note

gcd(x, y) is greatest common divisor of x and y.
import javafx.util.Pair;
 
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
import java.util.Map.Entry;

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.InputMismatchException;
 
public class abc {
		
	static String[] temp= {"1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011"};
	static char[] ans;
	
		public static void main(String[] args) throws Exception {
			// TODO Auto-generated method stub
			InputReader s = new InputReader(System.in);
			PrintWriter p = new PrintWriter(System.out);
			int	n=s.nextInt();
			int k=s.nextInt();
			int v=0;
			int[] arr=new int[n];
			if(n==1 && k==0) {
				System.out.println(1);
			}else if(k<n/2) {
				System.out.println(-1);
			}else if(n==1) {
				System.out.println(-1);
			}else {
				int diff=k-n/2;
				arr[v++]=(diff+1)*1;
				arr[v++]=(diff+1)*2;
				int temp=(diff+1)*2;
				for( ; v<n ; v++) {
					arr[v]=++temp;
				}
				for(int i:arr) {
					System.out.print(i+" ");
				}
				System.out.println();
			}
			
		}
		private static boolean possible(long c, long m, long x, long sum) {
			// TODO Auto-generated method stub
			if(c<sum || m<sum) {
				return false;
			}
			if(c+m+x<sum) {
				return false;
			}
			return true;
		}
		public class Pair implements Comparable<Pair>{
	        int x;
	        int f;
	        public Pair(int a , int b){
	            x=a;
	            f=b;
	        }
	        
	        public int comprae(Pair p){
	            return p.f-this.f;
	        }

			@Override
			public int compareTo(Pair arg0) {
				// TODO Auto-generated method stub
				return 0;
			}
	    }
	    
		
		
		
		
		
		public static int helper(String[] arr , int pos , int k , int[][] dp) {
			if(pos==arr.length && k==0) {
				return 1;
			}
			if(pos==arr.length || k==0) return 0;
			if(dp[pos][k]!=-1) return dp[pos][k];
			for(int i=9 ; i>=0 ; i--) {
				String s1=temp[i];
				String curr=arr[pos];
				int con=convert(curr,s1);
				if(con==-1 || con>k) {
					continue;
				}
				ans[pos]=(char)(i+'0');
				int z=helper(arr,pos+1,k-con,dp);
				if(z==1) {
					dp[pos][k]=1;
					return 1;
				}
				ans[pos]='z';
			}
			return dp[pos][k]=0;
		}
		
		public static int convert(String curr , String s1) {
			int count=0;
			for(int i=0 ; i<7 ; i++) {
				char c1=curr.charAt(i);
				char c2=s1.charAt(i);
				if(c1=='1' && c2=='0') {
					return -1;
				}
				if(c1=='0' && c2=='1') {
					count++;
				}
			}
			return count;
		}
		
		static long power(long x, long y) 
	    { 
			long temp=0l; 
	        if( y == 0) 
	            return 1l; 
	        temp = power(x, y/2);  
	          
	        if (y%2 == 0) 
	            return temp*temp; 
	        else
	        { 
	            if(y > 0) 
	                return x * temp * temp; 
	            else
	                return (temp * temp) / x; 
	        } 
	    }  
		
		
		public static boolean helper(int[] arr1 , int[] arr2) {
			boolean[] temp=new boolean[3];
			if(arr1.length==0) return true;
			if(arr1[0]!=arr2[0]) return false;
			temp[arr1[0]+1]=true;
			for(int i=1 ; i<arr1.length ; i++) {
				
				if(arr1[i]==arr2[i]) {
					
				}else if(arr1[i]<arr2[i]) {
					if(!temp[2]) {
						return false;
					}
				}else {
					if(!temp[0]) {
						return false;
					}
				}
				temp[arr1[i]+1]=true;
			}
			return true;
		}
		
	
		public static ArrayList Divisors(long n) {
			ArrayList<Long> div = new ArrayList<>();
	 
			for (long i = 1; i <= Math.sqrt(n); i++) {
				if (n % i == 0) {
					div.add(i);
	 
					if (n / i != i)
						div.add(n / i);
				}
			}
			return div;
		}
	 
		public static int BinarySearch(long[] a, long k) {
			int n = a.length;
			int i = 0, j = n - 1;
			int mid = 0;
	 
			if (k < a[0])
				return 0;
			else if (k >= a[n - 1])
				return n;
			else {
				while (j - i > 1) {
					mid = (i + j) / 2;
	 
					if (k >= a[mid])
						i = mid;
					else
						j = mid;
				}
			}
	 
			return i + 1;
		}
	 
		public static long GCD(long a, long b) {
			if (b == 0)
				return a;
			else
				return GCD(b, a % b);
		}
	 
		public static long LCM(long a, long b) {
			return (a * b) / GCD(a, b);
		}
	 
		static class InputReader {
	 
			private final InputStream stream;
			private final byte[] buf = new byte[8192];
			private int curChar, snumChars;
			private SpaceCharFilter filter;
	 
			public InputReader(InputStream stream) {
				this.stream = stream;
			}
	 
			public int snext() {
				if (snumChars == -1)
					throw new InputMismatchException();
				if (curChar >= snumChars) {
					curChar = 0;
					try {
						snumChars = stream.read(buf);
					} catch (IOException e) {
						throw new InputMismatchException();
					}
					if (snumChars <= 0)
						return -1;
				}
				return buf[curChar++];
			}
	 
			static class pair implements Comparable<pair> {
				Integer x, y;
	 
				pair(int x, int y) {
					this.x = x;
					this.y = y;
				}
	 
				public int compareTo(pair o) {
					int result = x.compareTo(o.x);
					if (result == 0)
						result = y.compareTo(o.y);
	 
					return result;
				}
	 
				public String toString() {
					return x + " " + y;
				}
	 
				public boolean equals(Object o) {
					if (o instanceof pair) {
						pair p = (pair) o;
						return p.x - x == 0 && p.y - y == 0;
					}
					return false;
				}
	 
				public int hashCode() {
					return new Long(x).hashCode() * 31 + new Long(y).hashCode();
				}
			}
	 
			public int nextInt() {
				int c = snext();
				while (isSpaceChar(c)) {
					c = snext();
				}
				int sgn = 1;
				if (c == '-') {
					sgn = -1;
					c = snext();
				}
				int res = 0;
				do {
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					res *= 10;
					res += c - '0';
					c = snext();
				} while (!isSpaceChar(c));
				return res * sgn;
			}
	 
			public long nextLong() {
				int c = snext();
				while (isSpaceChar(c)) {
					c = snext();
				}
				int sgn = 1;
				if (c == '-') {
					sgn = -1;
					c = snext();
				}
				long res = 0;
				do {
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					res *= 10;
					res += c - '0';
					c = snext();
				} while (!isSpaceChar(c));
				return res * sgn;
			}
	 
			public int[] nextIntArray(int n) {
				int a[] = new int[n];
				for (int i = 0; i < n; i++) {
					a[i] = nextInt();
				}
				return a;
			}
	 
			public String readString() {
				int c = snext();
				while (isSpaceChar(c)) {
					c = snext();
				}
				StringBuilder res = new StringBuilder();
				do {
					res.appendCodePoint(c);
					c = snext();
				} while (!isSpaceChar(c));
				return res.toString();
			}
	 
			public String nextLine() {
				int c = snext();
				while (isSpaceChar(c))
					c = snext();
				StringBuilder res = new StringBuilder();
				do {
					res.appendCodePoint(c);
					c = snext();
				} while (!isEndOfLine(c));
				return res.toString();
			}
	 
			public boolean isSpaceChar(int c) {
				if (filter != null)
					return filter.isSpaceChar(c);
				return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
			}
	 
			private boolean isEndOfLine(int c) {
				return c == '\n' || c == '\r' || c == -1;
			}
	 
			public interface SpaceCharFilter {
				public boolean isSpaceChar(int ch);
			}
		}
	 
		static class CodeX {
			public static void sort(long arr[]) {
				merge_sort(arr, 0, arr.length - 1);
			}
	 
			private static void merge_sort(long A[], long start, long end) {
				if (start < end) {
					long mid = (start + end) / 2;
					merge_sort(A, start, mid);
					merge_sort(A, mid + 1, end);
					merge(A, start, mid, end);
				}
	 
			}
	 
			private static void merge(long A[], long start, long mid, long end) {
				long p = start, q = mid + 1;
				long Arr[] = new long[(int) (end - start + 1)];
				long k = 0;
	 
				for (int i = (int) start; i <= end; i++) {
					if (p > mid)
						Arr[(int) k++] = A[(int) q++];
	 
					else if (q > end)
						Arr[(int) k++] = A[(int) p++];
	 
					else if (A[(int) p] < A[(int) q])
						Arr[(int) k++] = A[(int) p++];
	 
					else
						Arr[(int) k++] = A[(int) q++];
				}
				for (int i = 0; i < k; i++) {
					A[(int) start++] = Arr[i];
				}
	 
			}
	 
		}
	 
	}

	
