Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.

This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.

Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.

Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.

It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.

Help Vasya to recover the initial set of cards with numbers.

Input

The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.

Output

If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.

Examples

Input

3 3 2


Output

2 1 2 

Input

5 -4 3


Output

-1


Input

5 -4 4


Output

2 4 1 4 1

Difficulty: MEDIUM
Tags: Greedy algorithms

Constructive algorithms
Skill types: Greedy algorithms

Starter code:

Solutions:
(n, d, L) = map(int, input().split())
sp = []
for _ in range(n - 1):
	if d <= 0:
		sp.append(1)
		d = 1 - d
	else:
		sp.append(L)
		d = L - d
if 1 <= d <= L:
	sp.append(d)
	print(*sp)
else:
	print(-1)


while True:
	try:

		def soln(n, d, l):
			t = 0
			seq = list()
			for i in range(1, n, 1):
				if d < 1:
					t = 1
					seq.append(1)
				else:
					t = l
					seq.append(l)
				d = t - d
			if 1 <= d <= l:
				print(*seq + [d])
			else:
				print('-1')

		def read():
			(n, d, l) = map(int, input().split())
			soln(n, d, l)
		if __name__ == '__main__':
			read()
	except EOFError:
		break


(n, left, max_num) = [int(x) for x in input().split()]
array = [0 for x in range(n)]
for i in range(n):
	if left > 0:
		array[i] = max_num
	else:
		array[i] = 1
	left = array[i] - left
array[n - 1] -= left
if array[n - 1] < 1 or array[n - 1] > max_num:
	print(-1)
else:
	for x in array:
		print(x, end=' ')


def sol(n, d, l):
	nneg = n // 2
	npos = n - nneg
	(minneg, maxneg) = (nneg, l * nneg)
	(minpos, maxpos) = (npos, l * npos)
	if not minpos - maxneg <= d <= maxpos - minneg:
		return -1
	if d < 0:
		tneg = -d + minpos
		pos = [1] * npos
		neg = [tneg // nneg] * nneg
		for i in range(tneg % nneg):
			neg[i] += 1
	else:
		tpos = d + minneg
		neg = [1] * nneg
		pos = [tpos // npos] * npos
		for i in range(tpos % npos):
			pos[i] += 1
	ret = []
	ptr = 0
	while ptr <= len(neg) - 1:
		ret.append(pos[ptr])
		ret.append(neg[ptr])
		ptr += 1
	if ptr <= len(pos) - 1:
		ret.append(pos[ptr])
	for (i, v) in enumerate(ret):
		if v == 0:
			if ret[i - 1] < l:
				ret[i - 1] += 1
				ret[i] += 1
			else:
				return -1
	return ' '.join([str(x) for x in ret])
[n, d, l] = [int(x) for x in input().split()]
print(sol(n, d, l))


r = []
(n, d, l) = map(int, input().split())
for i in range(1, n):
	k = 1 if d <= 0 else l
	r.append(k)
	d = k - d
if 1 <= d <= l:
	print(*r + [d])
else:
	print(-1)


def modify(a, target, limit):
	pos = sum([a[i] for i in range(len(a)) if i % 2 == 0])
	neg = sum([a[i] for i in range(len(a)) if i % 2 == 1])
	total = pos - neg
	if total == target:
		return a
	if total < target:
		diff = target - total
		for i in range(len(a)):
			if i % 2 == 0:
				if limit - a[i] >= diff:
					a[i] += diff
					return a
				else:
					diff -= limit - a[i]
					a[i] = limit
		if diff > 0:
			return None
	else:
		diff = total - target
		for i in range(len(a)):
			if i % 2 == 1:
				if limit - a[i] >= diff:
					a[i] += diff
					return a
				else:
					diff -= limit - a[i]
					a[i] = limit
		if diff > 0:
			return None
(n, d, l) = [int(i) for i in input().split()]
numbers = [1 for i in range(n)]
mod = modify(numbers, d, l)
if mod is None:
	print(-1)
else:
	print(' '.join([str(i) for i in mod]))


(n, d, l) = map(int, input().split())
if d < n - n // 2 - n // 2 * l or d > (n - n // 2) * l - n // 2:
	print(-1)
else:
	arr = [1] * n
	sum1 = l * (n - n // 2)
	sum2 = n // 2
	for i in range(0, n, 2):
		arr[i] = l
	i = 0
	j = 1
	while 1:
		if i < n:
			if arr[i] == 1:
				i += 2
		if j < n:
			if arr[j] == l:
				j += 2
		if sum1 - sum2 == d:
			break
		elif i < n:
			if sum1 - sum2 > d:
				sum1 -= 1
				arr[i] -= 1
		elif j < n:
			if sum1 - sum2 > d:
				sum2 += 1
				arr[j] += 1
	print(*arr)


(n, d, l) = map(int, input().split())
z = []
i = 0
while len(z) < n:
	if len(z) > 0:
		z.pop()
	if d == 0:
		x = l // 2
		if l // 2 == 0:
			x = 1
		z.append(x)
		z.append(x)
	elif d > 0:
		z.append(l)
		z.append(l - d)
	else:
		z.append(1)
		z.append(1 - d)
	d = z[-1]
for i in z:
	if i <= 0 or i > l:
		print(-1)
		exit()
print(*z)


(n, d, l) = map(int, input().split())
m1 = n // 2 * (1 - l)
m2 = n // 2 * (l - 1)
if n % 2 != 0:
	m1 += 1
	m2 += l
if not m1 <= d <= m2:
	print(-1)
	exit()
x = d - m1
res = [1 if i % 2 == 0 else l for i in range(n)]
i = 0
while x > 0:
	if i % 2 == 0:
		res[i] += min(l - 1, x)
	else:
		res[i] -= min(l - 1, x)
	if i + 2 < n:
		i += 2
	else:
		i = 1
	x -= min(l - 1, x)
print(*res)


(n, d, l) = map(int, input().split())
m = n // 2 * (1 - l)
M = n // 2 * (l - 1)
if n % 2 != 0:
	m += 1
	M += l
if not m <= d <= M:
	print(-1)
else:
	e = d - m
	l2 = [1 if i % 2 == 0 else l for i in range(n)]
	ci = 0
	while e > 0:
		if ci % 2 == 0:
			l2[ci] += min(l - 1, e)
		else:
			l2[ci] -= min(l - 1, e)
		if ci + 2 < n:
			ci += 2
		else:
			ci = 1
		e -= min(l - 1, e)
	for e in l2:
		print(e, end=' ')


(n, d, l) = map(int, input().split())
e = (n + 1) // 2
o = n - e
ans = [1] * n
if d > 0:
	cur = e - o
	rem = d - cur
	for i in range(0, n, 2):
		if rem > 0:
			ans[i] += min(l - 1, rem)
			rem -= min(l - 1, rem)
	if rem > 0:
		print(-1)
		exit()
	print(*ans)
else:
	cur = e - o
	rem = d - cur
	for i in range(1, n, 2):
		if rem < 0:
			ans[i] += min(l - 1, -rem)
			rem += min(l - 1, -rem)
	if rem < 0:
		print(-1)
		exit()
	print(*ans)


def magic(n, d, l):
	arr = [1] * n
	ans = [None] * n
	odd = arr[0::2]
	even = arr[1::2]
	if d > 0:
		val = d - (sum(odd) - sum(even))
		while val:
			for i in range(len(odd)):
				if val:
					odd[i] += 1
					val -= 1
				else:
					break
	if d <= 0:
		val = abs(d) - (sum(even) - sum(odd))
		while val:
			for i in range(len(even)):
				if val:
					even[i] += 1
					val -= 1
				else:
					break
	if max(odd) > l or max(even) > l:
		return -1
	ans[0::2] = odd
	ans[1::2] = even
	print(*ans)
	return ''
(a, b, c) = map(int, input().strip().split())
print(magic(a, b, c))


(n, d, l) = map(int, input().split())
arr = []
for i in range(n):
	arr.append(l)
ans = 0
if n % 2 == 1:
	ans = l
i = 1
while ans < d and i < n:
	diff = d - ans
	space = arr[i] - 1
	if space < diff:
		arr[i] = 1
		i = i + 2
		ans = ans + space
	else:
		ans = ans + diff
		arr[i] = arr[i] - diff
		break
i = 0
while ans > d and i < n:
	diff = ans - d
	space = arr[i] - 1
	if diff < space:
		arr[i] = arr[i] - diff
		ans = ans - diff
		break
	else:
		arr[i] = 1
		ans = ans - space
		i += 2
i = 1
while ans < d and i < n:
	diff = d - ans
	space = arr[i] - 1
	if space < diff:
		arr[i] = 1
		i = i + 2
		ans = ans + space
	else:
		ans = ans + diff
		arr[i] = arr[i] - diff
		break
i = 0
while ans > d and i < n:
	diff = ans - d
	space = arr[i] - 1
	if diff < space:
		arr[i] = arr[i] - diff
		ans = ans - diff
		break
	else:
		arr[i] = 1
		ans = ans - space
		i += 2
sum = 0
for i in range(n):
	if i % 2 == 0:
		sum = sum + arr[i]
	else:
		sum = sum - arr[i]
if sum == d:
	for i in arr:
		print(i, end=' ')
else:
	print('-1')


s = [int(i) for i in input().split()]
(n, d, m) = s
s1 = [1] * ((n + 1) // 2)
s2 = [1] * (n // 2)
if not (n + 1) // 2 - m * (n // 2) <= d <= m * (n + 1) // 2 - n // 2:
	print(-1)
else:
	while sum(s1) - sum(s2) != d:
		a = d - sum(s1) + sum(s2)
		i = 0
		if a > 0:
			k = s1
		else:
			k = s2
		while i != abs(a):
			k[i % len(k)] += 1
			i += 1
	s = [0] * n
	(a, b) = (0, 0)
	for i in range(n):
		if i % 2 == 0:
			s[i] = s1[a]
			a += 1
		else:
			s[i] = s2[b]
			b += 1
	print(*s)


from sys import exit
(n, d, l) = map(int, input().split())
arr = [1] * n
d1 = d
if d < 0:
	d1 = -d1
if n == 3 and l == 2 and (d == 0):
	arr[1] = 2
for i in range(n):
	if d1 == 0:
		break
	if i % 2 == 0:
		arr[i] = min(d1, l)
		add = min(d1, l)
		if d1 == add:
			if arr[i] + 1 <= l:
				arr[i] += 1
		d1 = abs(d) - sum([(-1) ** i * arr[i] for i in range(len(arr))])
		if d1 < 0:
			arr[i] -= abs(d1)
			d1 = 0
if d < 0:
	if n % 2 == 0:
		for i in range(0, len(arr), 2):
			(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
	else:
		for i in range(0, len(arr) - 1, 2):
			(arr[i], arr[i + 1]) = (arr[i + 1], arr[i])
		if arr[len(arr) - 2] + 2 <= l:
			arr[len(arr) - 2] += 2
		else:
			arr[len(arr) - 2] = l
if sum([(-1) ** i * arr[i] for i in range(len(arr))]) != d:
	print(-1)
	exit(0)
print(*arr)


(n, d, l) = map(int, input().split())
ans = []
for i in range(n - 1):
	if d < 1:
		ans.append(1)
		d = 1 - d
	else:
		ans.append(l)
		d = l - d
if 1 <= d <= l:
	print(*ans + [d])
else:
	print(-1)


(n, d, l) = list(map(int, input().split()))
a = [0] * n
for i in range(n):
	if i == n - 1:
		a[i] = d
	elif d >= l:
		a[i] = l
		d = l - d
	elif d < 1:
		a[i] = 1
		d = -d + 1
	else:
		a[i] = d + 1
		d = 1
if a[-1] > l or a[-1] < 1:
	print(-1)
else:
	for i in range(n):
		print(a[i], end=' ')


(n, d, l) = [int(x) for x in input().split()]
e = int(n / 2)
o = int(n - e)
if not (o - e * l <= d and d <= o * l - e):
	print(-1)
else:
	a = [None] * n
	for i in range(0, n):
		a[i] = 1
		if i % 2:
			d += 1
		else:
			d -= 1
	if d > 0:
		i = 0
		for i in range(0, n, 2):
			p = min(d, l - a[i])
			a[i] += p
			d -= p
			if d <= 0:
				break
	elif d < 0:
		for i in range(1, n, 2):
			p = min(-d, l - a[i])
			a[i] += p
			d += p
			if d >= 0:
				break
	for x in a:
		print(x)


nn = input()
a = [int(i) for i in nn.split()]
d = a[1]
l = a[2]
n = a[0]
oddn = int(n / 2) + n % 2
evenn = int(n / 2)
a = []
if d > oddn * l - evenn or d < oddn - evenn * l:
	print(-1)
else:
	if n % 2:
		d -= 1
	for i in range(n):
		a.append(int(1))
	for i in range(n):
		if i % 2 == 0:
			if d > 0:
				if d < l:
					a[i] += d
					d -= d
				else:
					a[i] += l - 1
					d -= l - 1
		elif d < 0:
			if d > -l:
				a[i] += -d
				d += -d
			else:
				a[i] += l - 1
				d += l - 1
	for i in range(n):
		print(a[i], end=' ')


from __future__ import division, print_function
import math
import os
import sys
from sys import stdin, stdout
from io import BytesIO, IOBase
from itertools import accumulate
from collections import deque
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 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 soretd(s):
	for i in range(1, len(s)):
		if s[i - 1] > s[i]:
			return False
	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 main():
	(n, d, l) = map(int, input().split())
	ans = []
	c = 0
	for i in range(n - 1):
		if d > 0:
			c = l
		else:
			c = 1
		ans.append(c)
		d = c - d
	ans.append(d)
	for i in ans:
		if i < 1 or i > l:
			print(-1)
			break
	else:
		print(*ans)
main()


(n, d, l) = map(int, input().split())
max_sum = l * ((n + 1) // 2)
min_sum = (n + 1) // 2
s = d + n // 2
v = d + l * (n // 2)
if s > max_sum or v < min_sum:
	print(-1)
else:
	i = 0
	j = 0
	even = [1] * (n // 2)
	ho = len(even)
	odd = [1] * ((n + 1) // 2)
	yo = len(odd)
	while sum(even) + d < min_sum:
		if i == ho:
			i = 0
		even[i] += 1
		if sum(even) + d > max_sum:
			even[i] -= 1
			break
		i += 1
	s = sum(even) + d
	while sum(odd) != s:
		if j == yo:
			j = 0
		odd[j] += 1
		j += 1
	o = 0
	e = 0
	for i in range(n):
		if i % 2 != 0:
			print(even[e], end=' ')
			e += 1
		else:
			print(odd[o], end=' ')
			o += 1


def magic(n, d, l):
	ans = [d]
	flag = 0
	for i in range(n - 1):
		temp = ans[i]
		if temp < 1:
			ans[i] = 1
			ans.append(1 - temp)
		else:
			ans[i] = l
			ans.append(l - temp)
	if not 1 <= ans[n - 1] <= l:
		flag = 1
	if flag == 0:
		return ans
	else:
		return -1
(n, d, l) = map(int, input().split())
magic = magic(n, d, l)
if magic != -1:
	for i in range(n):
		print(magic[i], end=' ')
else:
	print(-1)


from sys import stdin, stdout
nmbr = lambda : int(stdin.readline())
lst = lambda : list(map(int, input().split()))
for _ in range(1):
	(n, d, mx) = lst()
	ans = [1] * n
	sm = 0
	for i in range(n):
		if i & 1:
			sm -= ans[i]
		else:
			sm += ans[i]
	p = 0
	while p < n and sm != d:
		if p & 1 and sm > d and (ans[p] < mx):
			ans[p] += 1
			sm -= 1
		elif p & 1 == 0 and sm < d and (ans[p] < mx):
			ans[p] += 1
			sm += 1
		else:
			p += 1
	if sm == d:
		print(*ans)
	else:
		print(-1)


(n, d, l) = map(int, input().split())
(x, y) = ((n + 1) // 2 - l * (n // 2), l * ((n + 1) // 2) - n // 2)
if x > d or y < d:
	print(-1)
elif l == 1:
	print('1 ' * n)
else:
	(a, b) = (str(l) + ' ', '1 ')
	(u, v) = ((d - x) // (l - 1), (d - x) % (l - 1))
	p = (a + b) * (u // 2)
	if u % 2:
		p += a
		if v > 0:
			p += str(l - v) + ' '
	elif v > 0:
		p += str(1 + v) + ' '
	k = u + int(v > 0)
	if k < n:
		p += a * (k % 2) + (b + a) * ((n - k - k % 2) // 2) + b * ((n - k - k % 2) % 2)
	print(p)


(n, d, l) = map(int, input().split())
neg = n // 2
pos = n - neg
arr = [1] * n
if d > 0:
	(d, m) = divmod(d - n % 2, pos)
	for i in range(0, n, 2):
		arr[i] = d + 1
	for i in range(m):
		arr[i * 2] += 1
else:
	(d, m) = divmod(-d + n % 2, neg)
	for i in range(1, n, 2):
		arr[i] = d + 1
	for i in range(m):
		arr[i * 2 + 1] += 1
for e in arr:
	if e > l:
		print(-1)
		exit()
print(*arr)


(a, b, c) = [int(x) for x in input().split(' ')]
s = [1] * a
b = b - a % 2
if b >= 0:
	r = b % ((a + 1) // 2)
	q = b // ((a + 1) // 2)
else:
	r = -b % (a // 2)
	q = -b // (a // 2)
for i in range(a):
	if i % 2 == 0 and r != 0 and (b > 0):
		s[i] += q + 1
		r -= 1
	elif i % 2 == 0 and b > 0:
		s[i] += q
	elif i % 2 != 0 and r != 0 and (b < 0):
		s[i] += q + 1
		r -= 1
	elif i % 2 != 0 and b < 0:
		s[i] += q
m = max(s)
n = min(s)
if m > c or n < 1:
	print(-1)
else:
	print(' '.join(map(str, s)))


import math
import re
from fractions import Fraction
from collections import Counter

class Task:
	(n, d, l) = [0] * 3
	answer = ''

	def __init__(self):
		(self.n, self.d, self.l) = [int(x) for x in input().split()]

	def solve(self):
		(n, d, l) = (self.n, self.d, self.l)
		numbers = [1] * n
		specialSum = n % 2
		for i in range(0, n):
			if i % 2 == 0 and specialSum < d or (i % 2 == 1 and specialSum > d):
				delta = min(l - numbers[i], abs(d - specialSum))
				numbers[i] += delta
				specialSum += delta * (1 if d - specialSum > 0 else -1)
			if i % 2 == 0 and specialSum > d or (i % 2 == 1 and specialSum < d):
				delta = min(numbers[i] - 1, abs(d - specialSum))
				numbers[i] -= delta
				specialSum += delta * (1 if d - specialSum > 0 else -1)
		if specialSum != d:
			self.answer = '-1'
			return
		self.answer = re.sub('[\\[\\],]', '', str(numbers))

	def printAnswer(self):
		print(self.answer)
task = Task()
task.solve()
task.printAnswer()


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
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
mod = pow(10, 9) + 7
mod2 = 998244353

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

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

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

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)]
(n, d, limit) = sp()
answer = []
for i in range(n - 1):
	if d <= 0:
		answer.append(1)
		d = 1 - d
	else:
		answer.append(limit)
		d = limit - d
if 1 <= d <= limit:
	answer.append(d)
	print(*answer)
	exit()
outln(-1)