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.

Difficulty: MEDIUM
Tags: Number theory

Constructive algorithms

Starter code:

Solutions:
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase

def main():
	(n, k) = [int(x) for x in input().split()]
	x = k - (n // 2 - 1)
	if x < 1 or (n < 2 and k > 0):
		print(-1)
		return
	sequence = [0] * n
	sequence[0] = x
	if n > 1:
		sequence[1] = 2 * x
	if n >= 3:
		newValue = 1
		while newValue == x or newValue == 2 * x or newValue + 1 == x or (newValue + 1 == 2 * x):
			newValue += 1
		sequence[2] = newValue
	for i in range(3, n):
		newValue = sequence[i - 1] + 1
		if not i & 1:
			while newValue == x or newValue == 2 * x or newValue + 1 == x or (newValue + 1 == 2 * x):
				newValue += 1
		sequence[i] = newValue
	print(' '.join(map(lambda x: str(x), sequence)))
BUFFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
input = lambda : sys.stdin.readline().rstrip('\r\n')

def print(*args, **kwargs):
	sep = kwargs.pop('sep', ' ')
	file = kwargs.pop('file', sys.stdout)
	atStart = True
	for x in args:
		if not atStart:
			file.write(sep)
		file.write(str(x))
		atStart = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
main()


def answer(n, k):
	if n == 1:
		if k == 0:
			return [1]
		else:
			return [-1]
	if n // 2 > k:
		return [-1]
	elif n // 2 == k:
		return [i for i in range(1, n + 1)]
	else:
		t = k - (n - 2) // 2
		l = [0] * n
		l[0] = t
		l[1] = 2 * t
		i = 2 * t + 1
		j = 2
		n -= 2
		while n > 0:
			l[j] = i
			i += 1
			j += 1
			n -= 1
		return l
(n, k) = map(int, input().split())
print(*answer(n, k))


(n, k) = map(int, input().split())
if n // 2 > k or (k != 0 and n == 1):
	print(-1)
	exit(0)
ans = [0] * n
ans[0] = k - n // 2 + 1
if n > 1:
	ans[1] = 2 * ans[0]
	for i in range(2, n):
		ans[i] = ans[i - 1] + 1
print(*ans)


import os
import sys
from io import BytesIO, IOBase
import math
from decimal import Decimal
from decimal import *
from collections import defaultdict, deque
import heapq
from decimal import Decimal
getcontext().prec = 25
abcd = 'abcdefghijklmnopqrstuvwxyz'
MOD = pow(10, 9) + 7
BUFSIZE = 8192
from bisect import bisect_left, bisect_right

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
(n, k) = map(int, input().split(' '))
if n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
else:
	k = k - (n - 2) // 2
	ans = []
	if k <= 0:
		print(-1)
	else:
		z = 0
		for i in range(n - 2):
			z += 1
			if z == k or z == 2 * k:
				z += 1
				if z % 2 == 0 or z == 2 * k:
					z += 1
			ans.append(z)
		ans.append(k)
		ans.append(2 * k)
		if n % 2:
			print(*ans[::-1])
		else:
			print(*ans)


(n, k) = map(int, input().split())
var = k - n // 2 + 1
if k < n // 2:
	print(-1)
	exit()
if n == 1:
	print(1 if k == 0 else -1)
	exit()
g = 1
for i in range(n):
	if i == 0:
		print(var, end=' ')
	elif i == 1:
		print(2 * var, end=' ')
	else:
		print(2 * var + g, end=' ')
		g += 1


(n, k) = map(int, input().split())
if n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
	exit()
p = n // 2
if k < p:
	print(-1)
	exit()
buf = []
if k == p:
	for i in range(1, p + 1):
		buf.append(2 * i - 1)
		buf.append(2 * i)
else:
	buf.append(k + 1 - p)
	buf.append(2 * buf[-1])
	for i in range(1, p):
		x = buf[-1]
		buf.append(x + 1)
		buf.append(x + 2)
if n % 2:
	buf.append(buf[-1] + 1)
print(buf[0], end='')
for i in range(1, len(buf)):
	print('', buf[i], end='')
print('')


(n, k) = map(int, input().split())
if n > 1:
	k -= n // 2 - 1
else:
	k = -1 if k else 1
if k > 1:
	p = list(range(1, n + 1))
	i = n // k
	i += i & 1
	p[i] *= k
	p[i + 1] *= k
	print(' '.join(map(str, p)))
elif k == 1:
	print(' '.join(map(str, range(1, n + 1))))
else:
	print('-1')


(n, k) = tuple(map(int, input().split()))
if n % 2:
	pairs = (n - 1) // 2
else:
	pairs = n // 2
if pairs > k or (not pairs and k > 0):
	print(-1)
else:
	if pairs < k:
		answer = [k - pairs + 1]
		answer.append(answer[0] * 2)
		answer += [i for i in range(answer[1] + 1, answer[1] + n - 1)]
	else:
		answer = [i for i in range(1, n + 1)]
	print(' '.join(map(str, answer)))


(n, k) = list(map(int, input().split()))
if k == 0 and n == 1:
	print(777, end=' ')
elif n // 2 > k or n == 1:
	print(-1)
	exit()
else:
	real = k - (n - 2) // 2
	k -= real
	print(real * 2, real, end=' ')
	r = real * 2 + 10
	while k > 0:
		print(r, r + 1, end=' ')
		k -= 1
		r += 2
	if n % 2 == 1:
		print(999999999, end=' ')
print()


(n, k) = [int(c) for c in input().split()]
res = []
pairs = n // 2
if pairs == 0 and k == 0:
	print('42')
elif pairs == 0 or pairs > k:
	print('-1')
else:
	avg = k // pairs
	max = 0
	for i in range(1, pairs):
		max = avg * (2 * i + 1)
		res.append(avg * (2 * i))
		res.append(max)
	rest = avg + k % pairs
	t1 = max // rest + 1
	i = pairs
	res.append(rest * t1)
	res.append(rest * (t1 + 1))
	if n % 2 == 1:
		res.append(1)
	print(' '.join(map(str, res)))


(n, k) = map(int, input().split())
if n + k == 1:
	print(1)
	quit()
if n == 1 or n > 2 * (k + 1):
	print(-1)
	quit()
first = k + 1 - n // 2
a = [first, first * 2]
if first == 0:
	print(-1)
	quit()
for i in range(1, n - 1):
	a.append(a[1] + i)
print(' '.join((str(k) for k in a)))


(n, k) = [int(i) for i in input().split()]
if k == 0 and n == 1:
	print(1)
elif n == 1 or k < n // 2:
	print(-1)
else:
	t = k - (n - 2) // 2
	print(t, 2 * t, end=' ')
	for i in range(n - 2):
		print(t + t + i + 1, end=' ')


(n, k) = map(int, input().split())
if k == 0 and n == 1:
	print(1)
elif n // 2 > k or n == 1:
	print(-1)
else:
	x = k - n // 2 + 1
	print(x, x * 2, *range(x * 2 + 1, x * 2 + 1 + n - 2))


(n, k) = map(int, input().split())
if n == 1:
	if k == 0:
		print(1)
		exit(0)
	else:
		print(-1)
		exit(0)
if k < n // 2:
	print(-1)
	exit(0)
x = k - (n - 2) // 2
print(x, x * 2, end=' ')
for i in range(2, n):
	print(x * 2 + i)


def main():
	(n, k) = map(int, input().split())
	if n == 1 == k + 1:
		print(1)
		return
	if n < 2 or n // 2 > k:
		print(-1)
		return
	k -= n // 2 - 1
	res = list(range(k * 2 + 2, (k + n // 2) * 2))
	res.append(k)
	res.append(k * 2)
	if n & 1:
		res.append(k * 2 + 1)
	print(' '.join(map(str, res)))
main()


(n, k) = map(int, input().split())
if n == 1 and k == 0:
	print(1)
else:
	k -= (n - 2) // 2
	if n < 2 or k <= 0:
		print(-1)
	else:
		print(k, k * 2, end=' ')
		prv = int(k * 2)
		for i in range(0, n - 2):
			print(prv + 1, end=' ')
			prv += 1


(n, k) = map(int, input().split())
if k * 2 + 1 < n:
	print(-1)
elif n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
else:
	output = [-1] * 2
	a = k - (n // 2 - 1)
	output[0] = str(a)
	output[1] = str(2 * a)
	output.extend([str(i) for i in range(2 * a + 1, 2 * a + 1 + n - 2, 1)])
	print(' '.join(output))


(n, k) = map(int, input().strip().split())
l = [0] * n
if n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
	exit()
if k < int(n / 2):
	print(-1)
else:
	if int(n / 2) == k:
		d = 1
		for i in range(n):
			l[i] = d
			d += 1
	else:
		diff = k - int(n / 2) + 1
		l[0] = diff * 2
		l[1] = diff
		d = 1
		i = 2
		while i < n:
			if l[1] != d and l[0] != d:
				l[i] = d
				i += 1
			d += 1
	print(*l)


(n, k) = [int(x) for x in input().split()]
f = False
if n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
	exit()
if n % 2:
	f = True
	n -= 1
if n // 2 > k:
	print(-1)
else:
	now = k - (n // 2 - 1)
	print(now, 2 * now, end=' ')
	c = 0
	for i in range(1, 10 ** 9 + 1):
		if c == n - 2:
			break
		if i != now and i != now * 2:
			print(i, end=' ')
			c += 1
			if c == n - 2:
				break
	if f:
		print(10 ** 9)


def generate_sequence(n, k, N):
	if N == 1 and k == 0:
		return [1]
	if N == 1 or k < n:
		return -1
	if N == 2:
		return [k, k * 2]
	if N == 3:
		return [k, k * 2, k * 2 + 1]
	seq = list(range(2, 2 * n))
	remaining = k - (n - 1)
	last_in_seq = seq[len(seq) - 1]
	mult = last_in_seq // remaining + 2
	seq.append(remaining * mult)
	seq.append(remaining * (mult + 1))
	if len(seq) != N:
		seq.append(1)
	return seq
(n, k) = map(int, input().split())
n_moves = n // 2
ans = generate_sequence(n_moves, k, n)
if ans == -1:
	print(-1)
else:
	print(' '.join(map(str, ans[:])))


(n, k) = (int(i) for i in input().split())
k1 = (n - 2) // 2
x = k - (n - 2) // 2
l = [x, 2 * x]
if k >= n // 2:
	if n == 1 and k == 0:
		print(1)
	elif n == 1:
		print(-1)
	else:
		for i in range(n - 2):
			l.append(2 * x + 1 + i)
		print(*l)
else:
	print(-1)


(n, m) = map(int, input().split())
t = n // 2
if t > m or (n == 1 and m > 0):
	print(-1)
else:
	m -= t
	ans = []
	if m > 0:
		m += 1
		n -= 2
		ans.append(m)
		ans.append(m * 2)
	g = m * 2 + 1
	for i in range(g, g + n):
		ans.append(i)
	print(*ans)


(n, p) = map(int, input().split())
moves = n // 2
if n == 1 and p == 0:
	print(1)
elif p < moves or n < 2:
	print(-1)
elif p == moves:
	for i in range(1, n + 1):
		print(i, end=' ')
else:
	pfm = p - moves + 1
	print(pfm, 2 * pfm, end=' ')
	for i in range(2 * pfm + 1, 2 * pfm + n - 1):
		print(i, end=' ')


(n, k) = map(int, input().split())
if n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
elif k < n // 2:
	print(-1)
else:
	remain = (n - 2) // 2
	k -= remain
	ans = [k, 2 * k]
	count = 1
	f = 0
	while len(ans) < n:
		p1 = count
		p2 = count + 1
		if p1 == k or p2 == k or p1 == 2 * k or (p2 == 2 * k):
			count += 1
		else:
			ans.append(p1)
			if len(ans) == n:
				break
			ans.append(p2)
			count += 2
	print(*ans)


import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left
from types import GeneratorType
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		import os
		self.os = os
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			self.os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import time
start_time = time.time()
import collections as col
import math, string
from functools import reduce

def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())
MOD = 10 ** 9 + 7

def primes(n):
	sieve = [True] * n
	z = int(n ** 0.5) + 1
	for i in range(3, z, 2):
		if sieve[i]:
			sieve[i * i::2 * i] = [False] * ((n - i * i - 1) // (2 * i) + 1)
	return set([i for i in range(3, n, 2) if sieve[i]])
P = primes(1000000)

def solve():
	(N, K) = getInts()
	if N == 1:
		if K == 0:
			print(1)
			return
		else:
			print(-1)
			return
	ans = []
	if K < N // 2:
		print(-1)
		return
	if K > N // 2:
		y = K - N // 2 + 1
		ans.append(y)
		ans.append(2 * y)
		if y in P:
			P.remove(y)
		if y - 1 in P:
			P.remove(y - 1)
		if 2 * y - 1 in P:
			P.remove(2 * y - 1)
	while len(ans) < N - 1:
		p = next(iter(P))
		ans.append(p)
		ans.append(p + 1)
		P.remove(p)
	if len(ans) < N:
		ans.append(100000000)
	print(*ans)
	return
solve()


(n, k) = map(int, input().split())
if n // 2 > k or (n == 1 and k > 0):
	print(-1)
elif n > 1:
	v = k - n // 2 + 1
	res = [v, 2 * v]
	m = 2 * v + 1
	for _ in range(n // 2 - 1):
		res.append(m)
		m += 1
		res.append(m)
		m += 1
	if n % 2 == 1:
		res.append(m)
	print(*res)
else:
	print(1)


(n, k) = map(int, input().split(' '))
if k < n // 2 or (n == 1 and k != 0):
	print(-1)
elif k == 0:
	print('1')
else:
	c = k - n // 2 + 1
	li = [str(c), str(2 * c)]
	for i in range(2, n):
		li.append(str(int(li[i - 1]) + 1))
	print(' '.join(li))


(n, k) = map(int, input().split())
if n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
else:
	a = n // 2
	b = k // a
	c = k % a
	l = []
	if k < a:
		print(-1)
	else:
		i = 0
		for i in range(2 * (a - 1)):
			l.append(b * (i + 1))
		i += 1
		if c == 0:
			l.append(b * (i + 1))
			l.append(b * (i + 2))
		else:
			if len(l) != 0:
				d = l[-1] // (b + c)
			else:
				d = 0
			l.append((b + c) * (d + 1))
			l.append((b + c) * (d + 2))
		if n % 2 != 0:
			l.append(l[-1] + 1)
		print(*l)


(n, k) = map(int, input().split())
if k == 0 and n == 1:
	print(1)
elif k < n // 2 or n == 1:
	print(-1)
else:
	val = n // 2 - 1
	k -= val
	print(k, k * 2, end=' ')
	j = 1
	while val:
		if j == k or j == k * 2 or j + 1 == k or (j + 1 == k * 2):
			j += 1
			continue
		print(j, j + 1, end=' ')
		j += 2
		val -= 1
	if n % 2:
		print(999999999)


import sys
(n, k) = list(map(int, input().split()))
ans = []
if n // 2 > k or (n < 2 and k > 0):
	print(-1)
	sys.exit()
if k == 0:
	print(1)
	sys.exit()
if n // 2 == k:
	for i in range(1, n + 1):
		ans.append(i)
else:
	ans.append(k - (n // 2 - 1))
	ans.append(2 * (k - (n // 2 - 1)))
	for i in range(1, n - 1):
		ans.append(i + int(200000000.0))
ans = map(str, ans)
print(' '.join(ans))


(n, k) = map(int, input().split())
if n < 2:
	if k == 0:
		print(1)
	else:
		print(-1)
elif k < n // 2:
	print(-1)
else:
	can_get = n // 2
	ans = 0
	arr = []
	x = k - (n - 2) // 2
	arr.append(x)
	arr.append(2 * x)
	start = 2 * x
	i = start + 1
	while len(arr) < n - n % 2:
		ans += i + 1
		ans += i + 2
		arr.append(i + 1)
		arr.append(i + 2)
		i += 2
	if n % 2 == 1:
		arr.append(100000000)
	if max(arr) > 1000000000:
		print(-1)
	else:
		print(*arr)


(n, k) = map(int, input().split())
q = n // 2
if q > k:
	print(-1)
	exit()
if n < 2:
	if k:
		print(-1)
	else:
		print(1)
	exit()
a = b = k - q + 1
while a < n:
	a *= 2
while b <= a:
	b *= 3
print(a, b, *range(1, n - 1))


from sys import stdin
MAXNUM = int(2000000.0)
primes = list()
isprime = [True for i in range(MAXNUM + 1)]

def getPrimes():
	for i in range(2, MAXNUM + 1):
		if isprime[i]:
			primes.append(i)
			j = i * i
			while j < MAXNUM + 1:
				isprime[j] = False
				j += i

def solve(tc):
	(n, k) = map(int, stdin.readline().split())
	pairs = n // 2
	if pairs == 0:
		if k == 0:
			print(' '.join(map(lambda x: str(x), list(range(1, n + 1)))))
		else:
			print(-1)
		return
	if pairs > k:
		print(-1)
		return
	getPrimes()
	remain = k - (pairs - 1)
	ans = list()
	ans.extend([remain, remain * 2])
	p = 0
	while len(ans) < n:
		if primes[p] != remain and primes[p] != remain * 2:
			ans.append(primes[p])
		p += 1
	print(' '.join(map(lambda x: str(x), ans)))
tc = 1
solve(tc)


(n, k) = map(int, input().split())
mn = n // 2
if mn > k or (n == 1 and k > 0):
	print(-1)
	exit()
if n == 1 and k == 0:
	print(1)
	exit()
ret = []
for i in range(1, (n - 2) // 2 + 1):
	ret.extend((i * 2 - 1, i * 2))
v = k - mn + 1
if not ret or ret[-1] < v:
	ret.extend((v, v * 2))
else:
	ret.extend((v * 2903, v * 3533))
print(*ret + [10 ** 9] * (n & 1))


def pont(N, K):
	gg = []
	m = N // 2
	if N == 1 and K > 0:
		return -1
	if K < m:
		return -1
	for i in range(1, N + 1):
		gg.append(i)
	if K == m:
		return ' '.join(map(str, gg))
	elif K > m:
		dif = K - m
		gg[0] = gg[0] * (dif + 1)
		gg[1] = gg[1] * (dif + 1)
		if gg[0] > 10 ** 9 or gg[1] > 10 ** 9:
			return -1
		lower = max(gg)
		upper = max(gg) + 20
		mm = []
		if min(gg[0], gg[1]) > gg[len(gg) - 1]:
			return ' '.join(map(str, gg))
		if len(gg) > 2:
			for num in range(lower + 1, upper):
				if len(mm) == 2:
					break
				if num > 1 and len(mm) < 2:
					for i in range(2, num):
						if num % i == 0:
							break
					else:
						mm.append(num)
			for i in range(2, N):
				if len(mm) == 0:
					break
				if gg[i] == gg[0] or gg[i] == gg[1]:
					gg[i] = mm[0]
					mm.remove(mm[0])
		return ' '.join(map(str, gg))
NK = input().split()
N = int(NK[0])
K = int(NK[1])
ans = pont(N, K)
print(ans)


(n, k) = map(int, input().split(' '))
if k < n // 2:
	print(-1)
elif n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
else:
	x = k - n // 2 + 1
	L = [x, 2 * x]
	for i in range(n - 2):
		L.append(200000001 + i)
	for i in L:
		print(i, end=' ')


import sys
(n, k) = map(int, input().split())
num = n // 2
if num == 0:
	if k == 0:
		print(1)
		sys.exit()
	else:
		print(-1)
		sys.exit()
if num > k:
	print(-1)
	sys.exit()
a = k - (num - 1)
print(a * 3, a * 2, end=' ')
b = 10 ** 8 * 3 + 1
for i in range(num - 1):
	print(b, b + 1, end=' ')
	b = b + 2
if n % 2 == 1:
	print(999999999, end=' ')


(n, k) = map(int, input().split())
if n == 1:
	print(1 if k == 0 else -1)
else:
	pr = (n - 2) // 2
	k -= pr
	if k < 1:
		print(-1)
	else:
		res = []
		res += [k, 2 * k]
		res += list(range(2 * k + 1, 2 * k + 1 + 2 * pr))
		if n % 2:
			res += [2 * k + 1 + 2 * pr]
		print(*res)


(n, k) = map(int, input().split())
moves = n // 2
if k < moves:
	print(-1)
elif n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
else:
	toget = k - (moves - 1)
	l = []
	l.append(toget)
	l.append(toget * 2)
	x = toget * 2
	size = 2
	while size != n:
		l.append(x + 1)
		x += 1
		size += 1
	print(*l)


(n, k) = map(int, input().split())
r = n // 2
res = []
if k < r:
	print(-1)
elif n == 1 and k != 0:
	print(-1)
elif n == 1:
	print(1)
else:
	j = 1
	p = 1
	x = k - r + 1
	y = 2 * x
	while j < r:
		if p == x or p + 1 == x or p == y or (p + 1 == y):
			p += 2
		else:
			res.append(p)
			res.append(p + 1)
			p += 2
			j += 1
	res.append(x)
	res.append(y)
	if n % 2 != 0:
		res.append(10 ** 9)
	print(*res)


from sys import stdin, stdout

def INI():
	return int(stdin.readline())

def INL():
	return [int(_) for _ in stdin.readline().split()]

def INS():
	return stdin.readline()

def MOD():
	return pow(10, 9) + 7

def OPS(ans):
	stdout.write(str(ans) + '\n')

def OPL(ans):
	[stdout.write(str(_) + ' ') for _ in ans]
	stdout.write('\n')
from math import ceil
ANS = []
(n, k) = INL()
if n // 2 > k or (n == 1 and k != 0):
	OPS(-1)
else:
	s = n // 2 - 1
	ANS.extend([k - s, 2 * (k - s)])
	x = ANS[-1] + 1
	for _ in range(2 * s):
		ANS.append(x)
		x += 1
	ANS += [x + 1]
	OPL(ANS[:n])


def numbers(n, k):
	if k == 0 and n == 1:
		return [1]
	if n == 1 or k < n // 2:
		return [-1]
	(result, t) = (list(), k - (n - 2) // 2)
	result.append(t)
	result.append(2 * t)
	for i in range(n - 2):
		result.append(2 * t + i + 1)
	return result
(N, K) = [int(j) for j in input().split()]
print(*numbers(N, K))


import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
(n, k) = value()
if k == 0 and n == 1:
	print(1)
	exit()
if k < n // 2 or n == 1:
	print(-1)
	exit()
ans = []
pairs = n // 2
k -= pairs - 1
ans.append(k)
ans.append(k * 2)
k = 2 * k + 1
for i in range(pairs - 1):
	ans.append(k)
	ans.append(k + 1)
	k += 2
if n % 2 == 1:
	ans.append(ans[-1] + 1)
print(*ans)


(n, k) = map(int, input().split())
if k < n // 2:
	print(-1)
elif n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
elif n == 2:
	if k == 0:
		print(-1)
	else:
		print(k, 2 * k)
else:
	N = n // 2
	x = k - (N - 1)
	ans = [x, 2 * x]
	for i in range(N - 1):
		ans.append(ans[-1] + 1)
		ans.append(ans[-1] + 1)
	if n & 1:
		ans.append(ans[-1] + 1)
	print(*ans)


(n, k) = map(int, input().split())
ans = [i + 1 for i in range(n)]
if k < len(ans) // 2:
	print(-1)
	exit()
if k == len(ans) // 2:
	print(*ans)
	exit()
if len(ans) == 1:
	if k == 0:
		print(*ans)
	else:
		print(-1)
	exit()
if len(ans) % 2 == 0:
	if len(ans) == 2:
		ans[0] = k
		ans[1] = 2 * k
		print(*ans)
		exit()
	else:
		score = (len(ans) - 2) // 2
		make = k - score
		ans[-2] = ans[-3] + make - ans[-3] % make
		ans[-1] = ans[-2] + make
		print(*ans)
elif len(ans) == 3:
	ans[0] = k
	ans[1] = 2 * k
	ans[2] = ans[1] + 1
	print(*ans)
	exit()
else:
	score = (len(ans) - 2) // 2
	make = k - score
	ans[-3] = ans[-4] + make - ans[-4] % make
	ans[-2] = ans[-3] + make
	print(*ans)


(n, k) = map(int, input().split())
if n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
elif k < n // 2:
	print(-1)
else:
	z = k - (n - 2) // 2
	print(z, z * 2, end=' ')
	for i in range(2, n):
		print(2 * z + i, end=' ')


(n, k) = list(map(int, input().split()))
if k < n // 2:
	print(-1)
elif n == 1:
	print(1 if k == 0 else -1)
else:
	x = k - (n - 2) // 2
	res = [x, 2 * x]
	c = 1
	for i in range((n - 2) // 2):
		while c == x or x == 2 * x or c + 1 == x or (c + 1 == 2 * x):
			c += 2
		res += [c, c + 1]
		c += 2
	else:
		if n % 2 == 1:
			while c == x or c == 2 * x:
				c += 1
			res.append(c)
	print(*res)


from __future__ import division, print_function
import math
import os
import sys
from fractions import *
from sys import *
from io import BytesIO, IOBase
from itertools import *
from collections import *
M = 10 ** 9 + 7
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def fsep():
	return map(float, inp().split())

def inpu():
	return int(inp())

def regularbracket(t):
	p = 0
	for i in t:
		if i == '(':
			p += 1
		else:
			p -= 1
		if p < 0:
			return False
	else:
		if p > 0:
			return False
		else:
			return True

def binarySearchCount(arr, n, key):
	left = 0
	right = n - 1
	count = 0
	while left <= right:
		mid = int((right + left) / 2)
		if arr[mid] <= key:
			count = mid + 1
			left = mid + 1
		else:
			right = mid - 1
	return count

def reverse1(string):
	pp = ''
	for i in string[::-1]:
		pp += i
	if pp == string:
		return True
	return False

def reverse2(list1):
	l = []
	for i in list1[::-1]:
		l.append(i)
	if l == list1:
		return True
	return False

def mex(list1):
	p = max(list1) + 1
	for i in range(len(list1)):
		if list1[i] != i:
			p = i
			break
	return p

def sumofdigits(n):
	n = str(n)
	s1 = 0
	for i in n:
		s1 += int(i)
	return s1

def perfect_square(n):
	s = math.sqrt(n)
	if s == int(s):
		return True
	return False

def roman_number(x):
	if x > 15999:
		return
	value = [5000, 4000, 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
	symbol = ['F', 'MF', 'M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']
	roman = ''
	i = 0
	while x > 0:
		div = x // value[i]
		x = x % value[i]
		while div:
			roman += symbol[i]
			div -= 1
		i += 1
	return roman

def soretd(s):
	for i in range(1, len(s)):
		if s[i - 1] > s[i]:
			return False
	return True

def countRhombi(h, w):
	ct = 0
	for i in range(2, h + 1, 2):
		for j in range(2, w + 1, 2):
			ct += (h - i + 1) * (w - j + 1)
	return ct

def countrhombi2(h, w):
	return h * h // 4 * (w * w // 4)

def binpow(a, b):
	if b == 0:
		return 1
	else:
		res = binpow(a, b // 2)
	if b % 2 != 0:
		return res * res * a
	else:
		return res * res

def binpowmodulus(a, b, m):
	a %= m
	res = 1
	while b > 0:
		if b & 1:
			res = res * a % m
		a = a * a % m
		b >>= 1
	return res

def coprime_to_n(n):
	result = n
	i = 2
	while i * i <= n:
		if n % i == 0:
			while n % i == 0:
				n //= i
			result -= result // i
		i += 1
	if n > 1:
		result -= result // n
	return result

def prime(x):
	if x == 1:
		return False
	else:
		for i in range(2, int(math.sqrt(x)) + 1):
			if x % i == 0:
				return False
		else:
			return True

def luckynumwithequalnumberoffourandseven(x, n, a):
	if x >= n and str(x).count('4') == str(x).count('7'):
		a.append(x)
	elif x < 1000000000000.0:
		luckynumwithequalnumberoffourandseven(x * 10 + 4, n, a)
		luckynumwithequalnumberoffourandseven(x * 10 + 7, n, a)
	return a

def luckynuber(x, n, a):
	p = set(str(x))
	if len(p) <= 2:
		a.append(x)
	if x < n:
		luckynuber(x + 1, n, a)
	return a

def interact(type, x):
	if type == 'r':
		inp = input()
		return inp.strip()
	else:
		print(x, flush=True)

def findTrailingZeros(n):
	count = 0
	while n >= 5:
		n //= 5
		count += n
	return count

def mergeSort(arr):
	if len(arr) > 1:
		mid = len(arr) // 2
		L = arr[:mid]
		R = arr[mid:]
		mergeSort(L)
		mergeSort(R)
		i = j = k = 0
		while i < len(L) and j < len(R):
			if L[i] < R[j]:
				arr[k] = L[i]
				i += 1
			else:
				arr[k] = R[j]
				j += 1
			k += 1
		while i < len(L):
			arr[k] = L[i]
			i += 1
			k += 1
		while j < len(R):
			arr[k] = R[j]
			j += 1
			k += 1
res = set()

def solven(p, l, a, b, n):
	if p > n or l > 10:
		return
	if p > 0:
		res.add(p)
	solven(p * 10 + a, l + 1, a, b, n)
	solven(p * 10 + b, l + 1, a, b, n)

def subsetsUtil(A, subset, index, d):
	print(*subset)
	s = sum(subset)
	d.append(s)
	for i in range(index, len(A)):
		subset.append(A[i])
		subsetsUtil(A, subset, i + 1, d)
		subset.pop(-1)
	return d

def subsetSums(arr, l, r, d, sum=0):
	if l > r:
		d.append(sum)
		return
	subsetSums(arr, l + 1, r, d, sum + arr[l])
	subsetSums(arr, l + 1, r, d, sum)
	return d

def print_factors(x):
	factors = []
	for i in range(1, x + 1):
		if x % i == 0:
			factors.append(i)
	return factors

def calc(X, d, ans, D):
	if len(X) == 0:
		return
	i = X.index(max(X))
	ans[D[max(X)]] = d
	Y = X[:i]
	Z = X[i + 1:]
	calc(Y, d + 1, ans, D)
	calc(Z, d + 1, ans, D)

def factorization(n, l):
	c = n
	if prime(n) == True:
		l.append(n)
		return l
	for i in range(2, c):
		if n == 1:
			break
		while n % i == 0:
			l.append(i)
			n = n // i
	return l

def good(b):
	l = []
	i = 0
	while len(b) != 0:
		if b[i] < b[len(b) - 1 - i]:
			l.append(b[i])
			b.remove(b[i])
		else:
			l.append(b[len(b) - 1 - i])
			b.remove(b[len(b) - 1 - i])
	if l == sorted(l):
		return True
	return False

def generate(st, s):
	if len(s) == 0:
		return
	if s not in st:
		st.add(s)
		for i in range(len(s)):
			t = list(s).copy()
			t.remove(s[i])
			t = ''.join(t)
			generate(st, t)
	return

def main():
	(n, k) = sep()
	l = []
	if k < n // 2:
		print(-1)
		exit()
	if n == 1 and k == 0:
		print(1)
		exit()
	if n == 1:
		print(-1)
		exit()
	for i in range(n):
		l.append(10 ** 9 - i)
	k = k - n // 2 + 1
	l[0] = k
	l[1] = k * 2
	print(*l)
main()


(n, k) = [int(i) for i in input().split()]
if n == 1 and k == 0:
	print(1)
elif n == 1 and k > 0:
	print(-1)
elif k < n // 2:
	print(-1)
elif n >= 2:
	if n % 2 == 0:
		m = n - 2
		summ = 0
		st = 10 ** 8
		while m > 0:
			print(st, end=' ')
			st += 1
			print(st, end=' ')
			summ += 1
			st += 1
			m -= 2
		diff = k - summ
		print(diff, diff * 8)
	else:
		m = n - 3
		summ = 0
		st = 10 ** 8
		while m > 0:
			print(st, end=' ')
			st += 1
			print(st, end=' ')
			summ += 1
			st += 1
			m -= 2
		diff = k - summ
		print(diff, diff * 8, end=' ')
		print(diff * 8 + 1)


import sys
[n, k] = map(int, sys.stdin.readline().split())

def solve():
	if n == 1 and k == 0:
		print(1)
		return
	if n == 1 and k > 0:
		print(-1)
		return
	if n // 2 > k:
		print(-1)
		return
	rest = k - n // 2
	print(rest + 1, end=' ')
	print(2 * rest + 2, end=' ')
	for i in range(2 * rest + 3, n + 2 * rest + 3 - 2):
		print(i, end=' ')
	print()
solve()


(n, k) = list(map(int, input().split()))
if n // 2 > k or (n == 1 and k != 0):
	print(-1)
elif n == 1 and k == 0:
	print(n)
else:
	k = k - (n - 2) // 2
	ans = [k, k * 2]
	for i in range(n - 2):
		ans.append(ans[-1] + 1)
	for i in range(n):
		print(ans[i], end=' ')


(n, k) = map(int, input().split())
t = n // 2
z = k - t + 1
ans = [10 ** 9 - i for i in range(1, n + 1)]
if z == 1:
	pass
elif z < 1 or n == 1:
	ans = [-1]
else:
	(ans[0], ans[1]) = (z, z * 2)
print(*ans)


import sys
input = sys.stdin.readline
I = lambda : list(map(int, input().split()))
(n, k) = I()
if k < n // 2 or (n == 1 and k != 0):
	print(-1)
elif n == 1:
	print(1)
else:
	x = r = k - (n - 2) // 2
	while r <= x + n:
		r += x
	an = [r, x]
	for i in range(2, n):
		an.append(an[1] + i - 1)
	print(*an)


class CodeforcesTask414ASolution:

	def __init__(self):
		self.result = ''
		self.n_k = []

	def read_input(self):
		self.n_k = [int(x) for x in input().split(' ')]

	def process_task(self):
		pairs = self.n_k[0] // 2
		if pairs > self.n_k[1]:
			self.result = '-1'
		elif self.n_k[0] == 1:
			if not self.n_k[1]:
				self.result = '1'
			else:
				self.result = '-1'
		else:
			numbers = []
			odd = self.n_k[0] % 2
			self.n_k[0] = self.n_k[0] - odd
			x = self.n_k[1] - (self.n_k[0] - 2) // 2
			numbers.append(x)
			numbers.append(x * 2)
			x *= 2
			x += 1
			for n in range(self.n_k[0] - 2):
				numbers.append(x)
				x += 1
			if odd:
				numbers.append(x)
			self.result = ' '.join([str(x) for x in numbers])

	def get_result(self):
		return self.result
Solution = CodeforcesTask414ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


(n, k) = [int(i) for i in input().split()]
d = k - n // 2
a = []
if n == 1 and k == 0:
	print(1)
elif n == 1 and k != 0:
	print(-1)
elif k < n // 2:
	print(-1)
else:
	for i in range(n):
		a.append(i + 1)
	if d != 0:
		d += 1
		if d > n:
			a[0] = d
			a[1] = 2 * d
		else:
			rem = n // d
			a[0] = (rem + 1) * d
			a[1] = (rem + 2) * d
	print(*a)


(n, k) = map(int, input().split())
if n // 2 > k or (k != 0 and n == 1):
	print(-1)
elif n == 1:
	print(1)
else:
	a = k - (n - 2) // 2
	print(a, a * 2, end=' ')
	for x in range(a * 2 + 1, a * 2 - 1 + n):
		print(x, end=' ')


(n, k) = map(int, input().split())
pares = n // 2
unos = pares - 1
nn = k - unos
if pares == 0 and k == 0:
	print(1)
elif pares == 0 or nn <= 0:
	print(-1)
else:
	ar = []
	a = nn
	b = 2 * nn
	ar.append(a)
	ar.append(b)
	last = None
	for i in range(1, 1000000000, 2):
		if len(ar) >= 2 * pares:
			last = i + 2
			break
		if i != a and i != b and (i + 1 != a) and (i + 1 != b):
			ar.append(i)
			ar.append(i + 1)
	if n % 2 == 1:
		for i in range(last, 1000000000):
			if i != a and i != b:
				ar.append(i)
				break
	print(*ar)


from math import ceil
from math import floor
from math import sqrt
from math import log

def mod_expo(n, p, m):
	result = 1
	while p != 0:
		if p % 2 == 1:
			result = result * n % m
		p //= 2
		n = n * n % m
	return result

def find_least_diff(n):
	A = 2 * (pow(2, n / 2 - 1) - 1)
	B = -pow(2, n / 2)
	return int(abs(B - A))

def find_ways(n):
	return (n - 1) // 2

def count_digits(n):
	m = 9
	count = n
	while True:
		if n >= m:
			count += n - m
		else:
			break
		m = str(m)
		m += '9'
		m = int(m)
	return count

def kth_bit_set(n, k):
	return n & 1 << k - 1

def sum_is_zero(n, arr):
	for i in range(pow(2, n)):
		angle_sum = 0
		for j in range(n):
			if kth_bit_set(i, j + 1):
				angle_sum += arr[j]
			else:
				angle_sum -= arr[j]
		if angle_sum % 360 == 0:
			return True
	return False

def get_board(n, m, mat):
	for i in range(n):
		for j in range(m):
			print(i, j)
			if mat[i][j] == '.':
				if (j > 0 and mat[i][j - 1] != 'B') and (i > 0 and mat[i - 1][j] != 'B'):
					mat[i][j] = 'B'
				else:
					mat[i][j] = 'W'
	for i in range(n):
		for j in range(m):
			print(mat[i][j])

def check_and_print_pyth_triplets(n):
	if n <= 2:
		print(-1)
	elif n % 2 == 0:
		temp = n * n
		m = temp / 4 - 1
		k = temp / 4 + 1
		print(str(m), str(k))
	else:
		temp = n * n
		m = (temp - 1) / 2
		k = (temp + 1) / 2
		print(str(m), str(k))

def can_equalize(n, arr, b):
	a = 0
	g = 0
	result = ''
	for i in range(n):
		if a + arr[i] - g <= 500:
			a += arr[i]
			result += 'A'
		else:
			g += b[i]
			result += 'G'
	if abs(a - g) <= 500:
		return result
	return '-1'

def is_square(a1, b1, a2, b2):
	if a1 == a2 and b1 + b2 == a1:
		return True
	elif a1 == b2 and b1 + a2 == a1:
		return True
	elif b1 == a2 and a1 + b2 == b1:
		return True
	elif b1 == b2 and a1 + a2 == b1:
		return True
	return False

def find_given_gcd(n, k):
	if n == 1:
		if k == 0:
			return [2]
		return [-1]
	if k >= n // 2:
		answers = []
		x = k - floor((n - 2) / 2)
		answers.append(x)
		answers.append(2 * x)
		current = 2 * x + 1
		count = 2
		while count < n:
			answers.append(current)
			count += 1
			current += 1
		return answers
	return [-1]

def there_is_a_way(n, pipes):
	row = 0
	for c in range(0, n):
		if pipes[c][row] <= 2:
			continue
		else:
			nxt_row = (row + 1) % 2
			if pipes[c][nxt_row] > 2:
				row = nxt_row
			else:
				return false
	return row == 1

def contest_function(n, arr):
	count = 1
	i = n - 1
	mx = 0
	while i > 0:
		if arr[i] <= 2 * arr[i - 1]:
			count += 1
		else:
			mx = max(mx, count)
			count = 1
		i -= 1
	return mx

def fun(y):
	return 1 / 3 * (1 / sqrt(1 + y * y) + 1 / sqrt(25 + y * y) + 4 * (1 / sqrt(1 + 4 * y * y) + 1 / sqrt(1 + 16 * y * y)) + 2 * 1 / sqrt(1 + 9 * y * y))
t = 1
while t:
	t = t - 1
	count = 0
	(n, k) = map(int, input().split())
	arr = []
	b = []
	answers = find_given_gcd(n, k)
	print(*answers, sep=' ')


(n, m) = map(int, input().split())
if n == 1 and m == 0:
	print(1)
	quit()
if n // 2 > m or n == 1:
	print(-1)
	quit()
num = m - (n - 2) // 2
ans = [num, num * 2]
j = 1
for i in range(n - 2):
	while j == num or j == num * 2:
		j += 1
	ans.append(j)
	j += 1
for i in ans:
	print(i, end=' ')
print()


(n, k) = map(int, input().split())
q = n // 2
if q > k or (q == 0 and k != 0):
	print(-1)
elif q == 0 and k == 0:
	print(1)
else:
	w = []
	r = k // q
	l = {0}
	y = {}
	t = [r + 1, 0] * (k % q) + [r, 0] * (q - k % q)
	for i in range(0, 2 * q, 2):
		y[t[i]] = 1
	for i in range(0, 2 * q, 2):
		w += [t[i], t[i] * 2]
	for i in range(0, len(w), 2):
		while w[i] in l:
			y[t[i]] += 2
			w[i] = y[t[i]] * t[i]
		l.add(w[i])
		while w[i + 1] in l:
			y[t[i]] += 2
			w[i + 1] = y[t[i]] * t[i]
		l.add(w[i + 1])
	if n % 2:
		w += [10 ** 9]
	print(*w)


import sys
from math import log2, floor, ceil, sqrt, gcd
import bisect
sys.setrecursionlimit(10 ** 5)
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 1000000007
(n, k) = Ri()
odd = False
if n % 2 == 1:
	n -= 1
	odd = True
if n // 2 > k or (n == 0 and k != 0):
	print(-1)
elif n == 0 and k == 0:
	print(1)
else:
	k = k - n // 2 + 1
	print(k, end=' ')
	print(2 * k, end=' ')
	maxx = 2 * k + 1
	for i in range(n // 2 - 1):
		print(maxx, end=' ')
		maxx += 1
		print(maxx, end=' ')
		maxx += 1
	if odd:
		print(maxx, end=' ')


(n, k) = list(map(int, input().split()))
if k == 0:
	if n == 1:
		print(1)
	else:
		print(-1)
	exit(0)
if k < 2:
	print(-1)
	exit(0)
for i in range(1, k + 1):
	if i + (n - 2) // 2 == k:
		print(i, 2 * i, end=' ')
		val = 5 * 10 ** 8 + 1
		tot = 2
		while tot < n:
			print(val, end=' ')
			val += 1
			tot += 1
		print()
		exit(0)
print(-1)


(n, k) = map(int, input().split())
if n // 2 > k:
	print(-1)
elif n == 1 and k != 0:
	print(-1)
elif n == 1 and k == 0:
	print(1)
else:
	a = n // 2 - 1
	for i in range(1, a + 1):
		print(2 * i - 1, 2 * i, end=' ')
	print((k - a) * 3 + 4 * a - 4 * a % (k - a), 4 * a - 4 * a % (k - a) + (k - a) * 4, end=' ')
	if n % 2:
		print(998244353)


import sys

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
(n, k) = get_ints()
if n == 1 and k >= 1:
	print(-1)
elif k < n // 2:
	print(-1)
elif k == n // 2:
	Arr = [i for i in range(1, n + 1)]
	print(*Arr)
else:
	t = k - (n // 2 - 1)
	Arr = [t, 2 * t]
	myset = {t, 2 * t}
	k = 2
	start = 1
	while k < n:
		if start not in myset:
			Arr.append(start)
			myset.add(start)
			k += 1
		start += 1
	print(*Arr)


(n, k) = map(int, input().split())
if n // 2 > k:
	print(-1)
	exit()
if n == 1:
	print(1 if k == 0 else -1)
	exit()
(t, m) = (n // 2, 10 ** 9)
k -= t - 1
print(' '.join([str(m - i) for i in range((t - 1) * 2)]) + ' %d %d' % (k, k + k) + (' %d' % (m - n) if n & 1 else ''))


(n, k) = map(int, input().split())
if k == 0 and n == 1:
	print(1)
	exit()
if n == 1 or k < n // 2:
	print(-1)
	exit()
res = []
t = k - (n - 2) // 2
res.append(t)
res.append(2 * t)
for i in range(n - 2):
	res.append(t + t + i + 1)
print(*res)


(n, k) = map(int, input().split())
if k < n // 2:
	print(-1)
elif n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
else:
	li = []
	for i in range(1, n // 2):
		li.append(str(2 * i - 1))
		li.append(str(2 * i))
	v = k - n // 2 + 1
	kk = (1000000000 - 5) // v
	li.append(str(v * (kk - 1)))
	li.append(str(v * kk))
	if n & 1:
		li.append(str(v * kk + 1))
	print(' '.join(li))


(n, k) = [int(x) for x in input().split()]
if n is 1:
	if k is 0:
		print(1)
		exit()
	if k is not 0:
		print(-1)
		exit()
g = k - (n - 2) // 2
if g <= 0:
	print(-1)
	exit()
n = n - 1
print(g)
g = g * 2
while n > 0:
	n = n - 1
	print(g)
	g = g + 1


from math import log, ceil
from collections import defaultdict
(n, k) = [int(x) for x in input().split()]
l = [i for i in range(1, n + 1)]
d = k - n // 2 + 1
if n // 2 > k:
	print(-1)
elif n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
else:
	d = k - n // 2 + 1
	l[0] = d
	l[1] = 2 * d
	for i in range(2, n):
		l[i] = l[i - 1] + 1
	print(*l)


(n, k) = map(int, input().split())
min_points = n // 2
if n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
	exit()
if k < min_points:
	print(-1)
	exit()
else:
	req_gcd = k - min_points + 1
	print(req_gcd, req_gcd * 2, end=' ')
	rest_seq_start = 2 * req_gcd + 1
	n -= 2
	while n > 0:
		print(rest_seq_start, end=' ')
		n -= 1
		rest_seq_start += 1


from sys import stdin
__author__ = 'artyom'
(n, k) = list(map(int, stdin.readline().strip().split()))
if n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
	exit()
pairs = n // 2
if k < pairs:
	print(-1)
	exit()
(x, y) = (1, 2)
if k > pairs:
	x = k - pairs + 1
	y = x * 2
print(x, end=' ')
print(y, end=' ')
if n > 2:
	for i in range(y + 1, y + n - 2):
		print(i, end=' ')
	print(y + n - 2)


(n, k) = map(int, input().split())
t = n // 2
z = k - t + 1
ans = [i for i in range(1, n + 1)]
if z < 1:
	ans = [-1]
elif z == 1:
	pass
elif n == 1:
	ans = [-1]
elif z >= n:
	(ans[0], ans[1]) = (z, z * 2)
	if z == n and n > 2:
		ans[-1] += 1
elif z < n:
	if z % 2 == 0:
		ans[z - 2] = (n // z + 1) * z
	else:
		ans[z] = (n // z + 1) * z
print(*ans)


from math import *
from bisect import *
from collections import Counter, defaultdict
from sys import stdin, stdout
input = stdin.readline
I = lambda : int(input())
SI = lambda : input()
M = lambda : map(int, input().split())
LI = lambda : list(map(int, input().split()))
(n, k) = M()
a = []
b = n // 2
if b > k or (b == 0 and k > 0):
	print(-1)
elif b == 0:
	print(1)
else:
	c = k - (b - 1)
	a += [c, c + c]
	d = 2 * c + 1
	for i in range(d, d + n - 2):
		a += [i]
	print(*a)


(n, k) = map(int, input().split())
c = k - (n // 2 - 1)
l = []
if c <= 0 or n == 1:
	if n == 1 and k == 0:
		print(2)
	else:
		print(-1)
else:
	i = 1
	if n == 1:
		l.append(c)
	else:
		l.append(c)
		l.append(2 * c)
		i = 2 * c + 1
		while 1:
			if len(l) == n:
				break
			if i + 1 != l[0] and i + 1 != l[1]:
				l.append(i)
				i += 1
			else:
				i += 2
	print(*l)


import sys
import heapq
from collections import deque
from collections import defaultdict
I = lambda : list(map(int, input().split(' ')))

def check_dup(lst):
	d = set()
	for ele in lst:
		if ele in d or ele <= 0:
			return False
		d.add(ele)
	return True
(n, k) = I()
if n >= 2:
	nn = n
	s = []
	s.append(k - nn // 2 + 1)
	s.append(2 * (k - nn // 2 + 1))
	ii = 2 * (k - nn // 2 + 1)
	while len(s) < nn:
		ii += 1
		s.append(ii)
	if check_dup(s):
		print(' '.join(map(str, s)))
	else:
		print(-1)
elif n == 1 and k == 0:
	print(1)
elif n <= 2:
	print(-1)


(n, m) = map(int, input().split())
if m < n // 2 and n != 1 or (n == 1 and m >= n):
	print(-1)
else:
	if m:
		k = (n - 2) // 2
		print(m - k, end=' ')
		print((m - k) * 2, end=' ')
		n -= 2
		c = (m - k) * 2 + 1
	if n != 1:
		for i in range(c, c + n):
			print(i, end=' ')
	else:
		print(1)


from collections import *
(n, k) = list(map(int, input().split()))
if n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
	exit(0)
ct = k - (n - 2) // 2
if ct <= 0:
	print(-1)
	exit(0)
print(ct, 2 * ct, end=' ')
j = 1
for i in range(n - 2):
	if j == ct:
		j += 1
	if j == 2 * ct:
		j += 1
	print(j, end=' ')
	j += 1
print()


import sys
import math as mt
t = 1
for __ in range(t):
	(n, k) = map(int, input().split())
	l = []
	p = n // 2
	i = 0
	ch = 0
	ans = 0
	for i in range(p):
		ap = k - ans - (p - (i + 1))
		if ap > 1:
			l.append(ap)
			l.append(2 * ap)
			ans += ap
		elif ap == 1:
			if len(l) == 0:
				l.append(1)
				l.append(2)
				ans += 1
			else:
				ap2 = l[-1]
				l.append(ap2 + 1)
				ans += 1
				l.append(ap2 + 2)
		else:
			ch = 1
			break
	if ch == 1 or (n == 1 and k != 0):
		print(-1)
	elif n == 1 and k == 0:
		print(1)
	else:
		if len(l) != n:
			l.append(l[-1] + 1)
		print(*l)


import sys
input = sys.stdin.buffer.readline

def solution():
	(n, k) = map(int, input().split())
	if k == 0 and n == 1:
		print(1)
	elif n // 2 > k or n == 1:
		print(-1)
	else:
		x = k - n // 2 + 1
		print(x, x * 2, *range(x * 2 + 1, x * 2 + 1 + n - 2))
solution()


from os import path
import sys
from functools import cmp_to_key as ctk
from collections import deque, defaultdict as dd
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from itertools import permutations
from datetime import datetime
from math import ceil, sqrt, log, gcd

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def solve():
	(n, k) = mi()
	if n == 1:
		if k == 0:
			print(1)
		else:
			print('-1')
	else:
		n1 = n // 2
		if k < n1:
			print('-1')
			exit(0)
		elif k == n1:
			for i in range(1, n + 1):
				print(i, end=' ')
		else:
			n -= 2
			k -= n // 2
			if 2 * k > 1000000000.0:
				print('-1')
				exit(0)
			print(k, 2 * k, end=' ')
			x = 1
			i = 0
			while i < n:
				if x == k - 1 or x == 2 * k - 1:
					if i % 2 == 0:
						x += 2
						continue
				if x == k or x == 2 * k:
					x += 1
					continue
				print(x, end=' ')
				x += 1
				i += 1
if path.exists('input1.txt'):
	sys.stdin = open('input1.txt', 'r')
	sys.stdout = open('output1.txt', 'w')
else:
	input = sys.stdin.readline
solve()


(n, k) = [int(i) for i in input().split()]
odd = 0
if n % 2 != 0:
	n -= 1
	odd = 1
if k < n // 2 or n == 0:
	if n == 0 and k == 0:
		print(1)
	else:
		print(-1)
else:
	rem = k - (n // 2 - 1)
	arr = [rem, rem * 2]
	start = 300000000
	for i in range(n - 2 + odd):
		arr.append(start)
		start += 1
	print(*arr)


import sys
import bisect
input = sys.stdin.readline
l = input().split()
n = int(l[0])
k = int(l[1])
if k < n // 2:
	print(-1)
	quit()
if n == 1 and k != 0:
	print(-1)
	quit()
if n == 1:
	print(1)
	quit()
l = [i + 1 for i in range(n)]
z = k - n // 2
l[0] *= z + 1
l[1] *= z + 1
for i in range(2, n):
	l[i] = l[i - 1] + 1
for i in l:
	print(i, end=' ')


txt = input().split()
n = int(txt[0])
k = int(txt[1])
n_somas = n // 2
if k < n_somas or (n == 1 and k != 0):
	print(-1)
elif n == 1 and k == 0:
	print(1)
else:
	termo1 = k - (n - 2) // 2
	termo2 = 2 * termo1
	print(termo1, termo2, end=' ')
	ini = termo2
	for i in range(n - 2):
		ini = ini + 1
		print(ini, end=' ')


(n, k) = [int(x) for x in input().split()]
if k < n // 2:
	print(-1)
	exit()
if n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
	exit()
print(' '.join((str(x) for x in list(range(10 ** 9, 10 ** 9 - (n // 2 - 1) * 2, -1)) + [k - (n // 2 - 1), (k - (n // 2 - 1)) * 2] + ([10 ** 9 - (n // 2 - 1) * 2] if n % 2 else []))))


import time, math as mt, bisect, sys
from sys import stdin, stdout
from collections import deque
from fractions import Fraction
from collections import Counter
from collections import OrderedDict
pi = 3.141592653589793

def II():
	return int(stdin.readline())

def IO():
	return stdin.readline()

def IP():
	return map(int, stdin.readline().split())

def L():
	return list(map(int, stdin.readline().split()))

def P(x):
	return stdout.write(str(x) + '\n')

def PI(x, y):
	return stdout.write(str(x) + ' ' + str(y) + '\n')

def lcm(a, b):
	return a * b // gcd(a, b)

def gcd(a, b):
	if a == 0:
		return b
	elif b == 0:
		return a
	if a > b:
		return gcd(a % b, b)
	else:
		return gcd(a, b % a)

def readTree():
	v = int(input())
	adj = [set() for i in range(v + 1)]
	for i in range(v - 1):
		(u1, u2) = In()
		adj[u1].add(u2)
		adj[u2].add(u1)
	return (adj, v)

def bfs(adj, v):
	visited = [False] * (v + 1)
	q = deque()
	while q:
		pass

def sieve():
	li = [True] * 1000001
	(li[0], li[1]) = (False, False)
	for i in range(2, len(li), 1):
		if li[i] == True:
			for j in range(i * i, len(li), i):
				li[j] = False
	prime = []
	for i in range(1000001):
		if li[i] == True:
			prime.append(i)
	return prime

def setBit(n):
	count = 0
	while n != 0:
		n = n & n - 1
		count += 1
	return count
mx = 10 ** 7
spf = [mx] * (mx + 1)

def SPF():
	spf[1] = 1
	for i in range(2, mx + 1):
		if spf[i] == mx:
			spf[i] = i
			for j in range(i * i, mx + 1, i):
				if i < spf[j]:
					spf[j] = i
	return
mod = 10 ** 9 + 7

def solve():
	(n, k) = IP()
	if n == 1:
		if k == 0:
			P(1)
			return
		P(-1)
		return
	if k == 0:
		P(-1)
		return
	y = k - (n - 2) // 2
	li = []
	if (n - 2) // 2 < k:
		li.append(y)
		li.append(y * 2)
		for i in range(y * 2 + 1, y * 2 + n - 1):
			li.append(i)
		print(*li)
		return
	P(-1)
	return
solve()


(n, k) = map(int, input().split())
if n == 1 and k > 0:
	print(-1)
elif n == 1 and k == 0:
	print(1)
else:
	nums = []
	if k < n // 2:
		print(-1)
		exit()
	x = k - (n // 2 - 1)
	nums.append(x)
	nums.append(2 * x)
	if x > 2 * (n // 2 - 1):
		nums.extend(range(1, 2 * (n // 2 - 1) + 1))
	else:
		nums.extend(range(2 * x + 1, 2 * x + 1 + 2 * (n // 2 - 1) + 1))
	if len(nums) < n:
		nums.append(nums[-1] + 1 if nums[-1] + 1 != x else nums[-1] + 2)
	print(*nums[:n])


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353
from sys import stdin
input = stdin.readline

def data():
	return sys.stdin.readline().strip()

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def L():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
try:
	sys.stdin = open('input.txt', 'r')
except:
	pass
(n, k) = L()
if k == 0 and n == 1:
	print(1)
elif n // 2 > k or n == 1:
	print(-1)
else:
	x = k - n // 2 + 1
	print(x, x * 2, *range(x * 2 + 1, x * 2 + 1 + n - 2))
endtime = time.time()


(n, k) = map(int, input().split())
if n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
elif k < n // 2:
	print(-1)
else:
	x = n - 2
	y = x // 2
	z = k - y
	a = [z, 2 * z]
	w = 2 * z + 1
	while len(a) != n:
		a.append(w)
		w += 1
	print(*a)


import math, sys, bisect, heapq, os
from collections import defaultdict, Counter, deque
from itertools import groupby, accumulate
from functools import lru_cache
int1 = lambda x: int(x) - 1

def input():
	return sys.stdin.readline().rstrip('\r\n')
aj = lambda : list(map(int, input().split()))

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def Y(c):
	print(['NO', 'YES'][c])

def y(c):
	print(['no', 'yes'][c])

def Yy(c):
	print(['No', 'Yes'][c])

def solve():
	(n, k) = aj()
	if n == 1:
		if k == 0:
			print(1)
		else:
			print(-1)
	else:
		p = n // 2
		if k < p:
			print(-1)
		else:
			ans = [i for i in range(1, n + 1)]
			if n % 2:
				req = k - (p - 1)
				ans[-3] = req
				ans[-2] = 2 * req
				ans[-1] = 11832589
				if 0 < req <= n - 3:
					ans[req - 1] = 11832631
				if 0 < 2 * req <= n - 3:
					ans[2 * req - 1] = 11832661
			else:
				req = k - (p - 1)
				ans[-2] = req
				ans[-1] = 2 * req
				if 0 < req <= n - 2:
					ans[req - 1] = 11832631
				if 0 < 2 * req <= n - 2:
					ans[2 * req - 1] = 11832661
			print(*ans)
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass
solve()


(n, k) = map(int, input().split())
ans = [(1000000000 - 2 * i, 1000000000 - 2 * i - 1) for i in range(n // 2 - 1)] + [(k - (n // 2 - 1), 2 * (k - (n // 2 - 1)))]
if k < n // 2 or (k > 0 and n == 1):
	print(-1)
else:
	print(' '.join(['%d %d' % (ans[i][0], ans[i][1]) for i in range(n // 2)]) + (' 100500' if n % 2 == 1 else ''))


(n, k) = map(int, input().split())
if k < n // 2:
	print(-1)
	exit()
if k == n // 2:
	print(*range(1, n + 1))
	exit()
if n == 1:
	print(-1)
	exit()
reqd = k - n // 2 + 1
print(reqd, reqd * 2, end=' ')
for _ in range(1, n - 1):
	print(reqd * 2 + _, end=' ')


temparr = input()
temparr = temparr.split()
n = int(temparr[0])
k = int(temparr[1])
half = n // 2
if half > k:
	print('-1')
elif n == 1 and k != 0:
	print(-1)
elif n == 1:
	print('1')
elif half == k:
	cur = 1
	arr = []
	for i in range(1, n + 1):
		arr.append(str(i))
	print(' '.join(arr))
else:
	diff = 1 + k - half
	arr = []
	arr.append(str(diff))
	arr.append(str(diff * 2))
	diff2 = diff * 2
	for i in range(1, n - 1):
		diff2 += 1
		arr.append(str(diff2))
	print(' '.join(arr))


(n, k) = map(int, input().split())
if k == 0 and n == 1:
	print(1)
	exit(0)
if k > 0 and n == 1:
	print(-1)
	exit(0)
if k < n // 2:
	print(-1)
	exit(0)
first_pair = k - (n // 2 - 1)
ans = [first_pair, 2 * first_pair]
start = 2 * first_pair + 1
for i in range(n - 2):
	ans.append(start)
	start += 1
print(*ans)


class InputHandlerObject(object):
	inputs = []

	def getInput(self, n=0):
		res = ''
		inputs = self.inputs
		if not inputs:
			inputs.extend(input().split(' '))
		if n == 0:
			res = inputs[:]
			inputs[:] = []
		while n > len(inputs):
			inputs.extend(input().split(' '))
		if n > 0:
			res = inputs[:n]
			inputs[:n] = []
		return res
InputHandler = InputHandlerObject()
g = InputHandler.getInput
(n, k) = [int(x) for x in g()]
if k < n // 2:
	print(-1)
elif n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
else:
	m = k + 1 - n // 2
	r = [m, 2 * m]
	if m < 10 ** 6:
		r += [10 ** 7 + i for i in range(n - 2)]
	else:
		r += [1 + i for i in range(n - 2)]
	print(' '.join((str(x) for x in r)))


(n, k) = map(int, input().split())
if n // 2 > k or (n == 1 and k != 0):
	print(-1)
elif n == 1 and k == 0:
	print(1)
else:
	ext = k - n // 2 + 1
	ans = [ext, 2 * ext]
	n -= 2
	for i in range(1, 100001, 2):
		if n <= 1:
			break
		if i not in ans and i + 1 not in ans:
			print(i, i + 1, end=' ')
			n -= 2
	print(*ans, end=' ')
	if n & 1:
		print(1000000000)


(n, k) = map(int, input().split())
a = n // 2
z = k - a + 1
ans = [10 ** 9 - i for i in range(1, n + 1)]
if z == 1:
	print(*ans)
elif z < 1 or n == 1:
	print(-1)
elif n == 1:
	print(99)
else:
	(ans[0], ans[1]) = (z, z * 2)
	print(*ans)


arr = [int(x) for x in input().split()]
(n, k) = (arr[0], arr[1])
if k < n // 2:
	print(-1)
elif n == 1:
	if k > 0:
		print(-1)
	else:
		print(1)
else:
	ans = []
	if n % 2 == 0:
		temp = n // 2
		temp -= 1
		k -= temp
		i = 1
		print(k, 2 * k, end=' ')
		while temp > 0:
			if i != k and i != 2 * k and (i + 1 != k) and (i + 1 != 2 * k):
				print(i, i + 1, end=' ')
				temp -= 1
			i += 2
	else:
		temp = n // 2
		temp -= 1
		k -= temp
		i = 1
		print(k, 2 * k, end=' ')
		while temp > 0:
			if i != k and i != 2 * k and (i + 1 != k) and (i + 1 != 2 * k):
				print(i, i + 1, end=' ')
				temp -= 1
			i += 2
		print(i + 17)


(m, k) = [int(x) for x in input().split()]
n = m
if m % 2 == 1:
	n -= 1
if m == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
elif k < n // 2:
	print(-1)
else:
	x = k - (n // 2 - 1)
	ans = [str(x), str(2 * x)]
	i = 1
	while len(ans) < m:
		if i not in [x, 2 * x]:
			ans.append(str(i))
		i += 1
	print(' '.join(ans))


import sys
input = sys.stdin.buffer.readline
I = lambda : list(map(int, input().split()))
(n, k) = I()
if n == 1 and k == 0:
	print(1)
elif n // 2 > k or n == 1:
	print(-1)
elif n > 1:
	x = k - (n - 2) // 2
	ans = [x, 2 * x]
	d = 2 * x + 1
	for i in range(n // 2 - 1):
		ans += [d, d + 1]
		d += 2
	if len(ans) + 1 == n:
		ans.append(d)
	print(*ans)


(n, m) = map(int, input().split())
ans = []
c = 0
if m < n // 2:
	print(-1)
	exit()
elif n == 1 and m != 0:
	print(-1)
	exit()
elif n == 1 and m == 0:
	print(1)
	exit()
m -= n // 2 - 1
ans.append(1 * m)
ans.append(2 * m)
k = ans[-1]
for i in range(1, n - 2, 2):
	ans.append(k + i)
	ans.append(k + i + 1)
if n % 2 != 0:
	ans.append(10 ** 9)
print(*ans)


(n, k) = map(int, input().split())
if k < int(n / 2) or (n == 1 and k > 0):
	print(-1)
elif n == 1:
	print(1)
else:
	v = []
	v.append(k - int(n / 2) + 1)
	v.append(2 * (k - int(n / 2) + 1))
	i = 1
	while len(v) < n:
		if i != v[0] and i != v[1]:
			v.append(i)
		i = i + 1
	f = 0
	for i in v:
		if i > 1000000000:
			f = 1
			print(-1)
	if f == 0:
		for i in v:
			print(i, end=' ')


import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda : int(input())
li = lambda : list(map(int, input().split()))

def case():
	(n, k) = li()
	ans = []
	if n == 1:
		if k == 0:
			print(1)
		else:
			print(-1)
	elif k < n // 2:
		print(-1)
	else:
		ans.append(k + 1 - n // 2)
		ans.append(ans[0] * 2)
		for i in range(2, n):
			ans.append(ans[-1] + 1)
	print(*ans)
for _ in range(1):
	case()


(n, k) = map(int, input().split())
if k < n // 2 or (n == 1 and k != 0):
	print(-1)
elif n == 1:
	print(1)
else:
	x = r = k - (n - 2) // 2
	while r <= x + n:
		r += x
	ans = [r, x]
	for i in range(2, n):
		ans.append(ans[1] + i - 1)
	print(*ans)


(n, k) = list(map(int, input().split()))
sequ = []
t = n // 2
credits = k - t + 1
if n > 1:
	sequ.append(credits)
	sequ.append(2 * credits)
i = 2
itr = 2 * credits + 1
while i <= t:
	sequ.extend([itr, itr + 1])
	itr += 2
	i += 1
if n % 2 != 0:
	sequ.append(itr)
if n // 2 > k:
	print('-1')
elif n < 2 and k > 0:
	print('-1')
else:
	for x in sequ:
		print(x, end=' ')


(n, k) = map(int, input().split())
if n == 1 and k == 0:
	print(1)
	exit(0)
if k < n // 2 or n <= 1:
	print(-1)
	exit(0)
rem = k - n // 2
ans = []
a = 0
b = 0
if rem > 0:
	a = rem + 1
	b = 2 * (rem + 1)
	ans.append(rem + 1)
	ans.append(2 * (rem + 1))
count = 1
while len(ans) < n:
	if count != a and count != b:
		ans.append(count)
	count += 1
for num in ans:
	print(num, end=' ')
print()


t = input().split()
n = int(t[0])
k = int(t[1])
somas = n // 2
if k < somas or (n == 1 and k != 0):
	print(-1)
elif n == 1 and k == 0:
	print(1)
else:
	t1 = k - (n - 2) // 2
	t2 = 2 * t1
	print(t1, t2, end=' ')
	ini = t2
	for i in range(n - 2):
		ini = ini + 1
		print(ini, end=' ')


(numero, pontos) = input().split()
numero = int(numero)
pontos = int(pontos)
if int(numero / 2) > pontos or (int(numero / 2) == 0 and pontos != 0):
	print('-1\n', end='')
elif int(numero / 2) == pontos:
	i = 1
	while i <= numero:
		if i > 1:
			print(' ', end='')
		print(i, end='')
		i += 1
	print('\n', end='')
else:
	temporario = pontos - int(numero / 2) + 1
	print(str(temporario) + ' ' + str(temporario * 2), end='')
	i = temporario * 2 + 1
	j = 1
	while j < int(numero / 2):
		print(' ' + str(i) + ' ' + str(i + 1), end='')
		i += 2
		j += 1
	if numero % 2 == 1:
		print(' ' + str(i), end='')
	print('\n', end='')


import sys
(n, k) = list(map(int, input().split()))
if k < n // 2 or (n == 1 and k):
	print(-1)
	exit(0)
if n == 1:
	print(1)
	exit(0)
score = ((n ^ 1) - 2) // 2
gcd = k - score
ans1 = 200000000 - 200000000 % gcd
ans2 = ans1 + gcd
print(ans1, ans2, end=' ')
for i in range(1, n - 2 + 1):
	print(i, end=' ')


(n, k) = input().split(' ')
n = int(n)
k = int(k)
m = int(n / 2)
if m > k:
	print(-1)
elif m == 0:
	if k == 0:
		print(2314)
	else:
		print(-1)
else:
	print(k - m + 1, (k - m + 1) * 2, end=' ')
	j = 200000005
	for i in range(m - 1):
		print(j, j + 1, end=' ')
		j = j + 2
	if n % 2 == 1:
		print(900000000)


import math
(n, k) = [int(i) for i in input().split()]
if n == 1:
	if k == 0:
		print(1)
	else:
		print(-1)
elif k < n // 2:
	print(-1)
else:
	e = (n - 2) // 2
	el = k - e
	current = 2 * el
	res = [el, current]
	for _ in range(n - 2):
		current += 1
		res.append(current)
	print(' '.join([str(i) for i in res]))


import sys, os, io

def rs():
	return sys.stdin.readline().rstrip()

def ri():
	return int(sys.stdin.readline())

def ria():
	return list(map(int, sys.stdin.readline().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math, datetime, functools, itertools, operator, bisect, fractions, statistics
from collections import deque, defaultdict, OrderedDict, Counter
from fractions import Fraction
from decimal import Decimal
from sys import stdout
from heapq import heappush, heappop, heapify, _heapify_max, _heappop_max, nsmallest, nlargest
sys.setrecursionlimit(111111)
INF = 99999999999999999999999999999999

class SortedList:

	def __init__(self, iterable=[], _load=200):
		values = sorted(iterable)
		self._len = _len = len(values)
		self._load = _load
		self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
		self._list_lens = [len(_list) for _list in _lists]
		self._mins = [_list[0] for _list in _lists]
		self._fen_tree = []
		self._rebuild = True

	def _fen_build(self):
		self._fen_tree[:] = self._list_lens
		_fen_tree = self._fen_tree
		for i in range(len(_fen_tree)):
			if i | i + 1 < len(_fen_tree):
				_fen_tree[i | i + 1] += _fen_tree[i]
		self._rebuild = False

	def _fen_update(self, index, value):
		if not self._rebuild:
			_fen_tree = self._fen_tree
			while index < len(_fen_tree):
				_fen_tree[index] += value
				index |= index + 1

	def _fen_query(self, end):
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		x = 0
		while end:
			x += _fen_tree[end - 1]
			end &= end - 1
		return x

	def _fen_findkth(self, k):
		_list_lens = self._list_lens
		if k < _list_lens[0]:
			return (0, k)
		if k >= self._len - _list_lens[-1]:
			return (len(_list_lens) - 1, k + _list_lens[-1] - self._len)
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		idx = -1
		for d in reversed(range(len(_fen_tree).bit_length())):
			right_idx = idx + (1 << d)
			if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
				idx = right_idx
				k -= _fen_tree[idx]
		return (idx + 1, k)

	def _delete(self, pos, idx):
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len -= 1
		self._fen_update(pos, -1)
		del _lists[pos][idx]
		_list_lens[pos] -= 1
		if _list_lens[pos]:
			_mins[pos] = _lists[pos][0]
		else:
			del _lists[pos]
			del _list_lens[pos]
			del _mins[pos]
			self._rebuild = True

	def _loc_left(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(lo, pos) = (-1, len(_lists) - 1)
		while lo + 1 < pos:
			mi = lo + pos >> 1
			if value <= _mins[mi]:
				pos = mi
			else:
				lo = mi
		if pos and value <= _lists[pos - 1][-1]:
			pos -= 1
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value <= _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def _loc_right(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(pos, hi) = (0, len(_lists))
		while pos + 1 < hi:
			mi = pos + hi >> 1
			if value < _mins[mi]:
				hi = mi
			else:
				pos = mi
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value < _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def add(self, value):
		_load = self._load
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len += 1
		if _lists:
			(pos, idx) = self._loc_right(value)
			self._fen_update(pos, 1)
			_list = _lists[pos]
			_list.insert(idx, value)
			_list_lens[pos] += 1
			_mins[pos] = _list[0]
			if _load + _load < len(_list):
				_lists.insert(pos + 1, _list[_load:])
				_list_lens.insert(pos + 1, len(_list) - _load)
				_mins.insert(pos + 1, _list[_load])
				_list_lens[pos] = _load
				del _list[_load:]
				self._rebuild = True
		else:
			_lists.append([value])
			_mins.append(value)
			_list_lens.append(1)
			self._rebuild = True

	def discard(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_right(value)
			if idx and _lists[pos][idx - 1] == value:
				self._delete(pos, idx - 1)

	def remove(self, value):
		_len = self._len
		self.discard(value)
		if _len == self._len:
			raise ValueError('{0!r} not in list'.format(value))

	def pop(self, index=-1):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		value = self._lists[pos][idx]
		self._delete(pos, idx)
		return value

	def bisect_left(self, value):
		(pos, idx) = self._loc_left(value)
		return self._fen_query(pos) + idx

	def bisect_right(self, value):
		(pos, idx) = self._loc_right(value)
		return self._fen_query(pos) + idx

	def count(self, value):
		return self.bisect_right(value) - self.bisect_left(value)

	def __len__(self):
		return self._len

	def __getitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		return self._lists[pos][idx]

	def __delitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		self._delete(pos, idx)

	def __contains__(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_left(value)
			return idx < len(_lists[pos]) and _lists[pos][idx] == value
		return False

	def __iter__(self):
		return (value for _list in self._lists for value in _list)

	def __reversed__(self):
		return (value for _list in reversed(self._lists) for value in reversed(_list))

	def __repr__(self):
		return 'SortedList({0})'.format(list(self))

def main():
	mod = 1000000007
	starttime = datetime.datetime.now()
	if os.path.exists('input.txt'):
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	tc = 1
	for _ in range(tc):
		(n, k) = ria()
		if k < n // 2 or (n == 1 and k > 0):
			print(-1)
			break
		c = 1
		ans = []
		flag = 0
		if n % 2:
			flag = 1
		kl = k - (n // 2 - 1)
		d = {}
		if n > 1:
			ans.append(kl)
			ans.append(kl * 2)
		kl *= 2
		for i in range(n // 2 - 1):
			kl += 2
			ans.append(kl)
			ans.append(kl + 1)
		if flag:
			ans.append(1000000000 - 1)
		wia(ans)
	endtime = datetime.datetime.now()
	time = (endtime - starttime).total_seconds() * 1000
	if os.path.exists('input.txt'):
		print('Time:', time, 'ms')

class FastReader(io.IOBase):
	newlines = 0

	def __init__(self, fd, chunk_size=1024 * 8):
		self._fd = fd
		self._chunk_size = chunk_size
		self.buffer = io.BytesIO()

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self, size=-1):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

class FastWriter(io.IOBase):

	def __init__(self, fd):
		self._fd = fd
		self.buffer = io.BytesIO()
		self.write = self.buffer.write

	def flush(self):
		os.write(self._fd, self.buffer.getvalue())
		(self.buffer.truncate(0), self.buffer.seek(0))

class FastStdin(io.IOBase):

	def __init__(self, fd=0):
		self.buffer = FastReader(fd)
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

class FastStdout(io.IOBase):

	def __init__(self, fd=1):
		self.buffer = FastWriter(fd)
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.flush = self.buffer.flush
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()