Valera had two bags of potatoes, the first of these bags contains x (x ≥ 1) potatoes, and the second — y (y ≥ 1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains x potatoes) Valera lost. Valera remembers that the total amount of potatoes (x + y) in the two bags, firstly, was not gerater than n, and, secondly, was divisible by k.

Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.


-----Input-----

The first line of input contains three integers y, k, n (1 ≤ y, k, n ≤ 10^9; $\frac{n}{k}$  ≤ 10^5).


-----Output-----

Print the list of whitespace-separated integers — all possible values of x in ascending order. You should print each possible value of x exactly once.

If there are no such values of x print a single integer -1.


-----Examples-----
Input
10 1 10

Output
-1

Input
10 6 40

Output
2 8 14 20 26

Difficulty: EASY
Tags: Mathematics

Implementation

Greedy algorithms
Skill types: Greedy algorithms

Starter code:

Solutions:
(y, k, n) = map(int, input().split())
l1 = n % k
n -= l1
t = n - y
if t == 0:
	print(-1)
elif y >= n:
	print(-1)
elif t < k:
	print(t)
else:
	li = []
	for i in range(t, 0, -k):
		li.append(i)
	print(*li[::-1])


from functools import reduce
from collections import Counter
import time
import datetime

def time_t():
	print('Current date and time: ', datetime.datetime.now())
	print('Current year: ', datetime.date.today().strftime('%Y'))
	print('Month of year: ', datetime.date.today().strftime('%B'))
	print('Week number of the year: ', datetime.date.today().strftime('%W'))
	print('Weekday of the week: ', datetime.date.today().strftime('%w'))
	print('Day of year: ', datetime.date.today().strftime('%j'))
	print('Day of the month : ', datetime.date.today().strftime('%d'))
	print('Day of week: ', datetime.date.today().strftime('%A'))

def ip():
	return int(input())

def sip():
	return input()

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

def mips():
	return map(str, input().split())

def lip():
	return list(map(int, input().split()))

def matip(n, m):
	lst = []
	for i in range(n):
		arr = lip()
		lst.append(arr)
	return lst

def factors(n):
	return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))

def minJumps(arr, n):
	jumps = [0 for i in range(n)]
	if n == 0 or arr[0] == 0:
		return float('inf')
	jumps[0] = 0
	for i in range(1, n):
		jumps[i] = float('inf')
		for j in range(i):
			if i <= j + arr[j] and jumps[j] != float('inf'):
				jumps[i] = min(jumps[i], jumps[j] + 1)
				break
	return jumps[n - 1]

def dic(arr):
	return Counter(arr)
(y, k, n) = mip()
z = k - y % k
n = n - y
lst = []
while z <= n:
	lst.append(z)
	z += k
if lst:
	print(*lst)
else:
	print(-1)


def potatoes(y, k, n):
	arr = list(range(k, n + 1, k))
	arr = [i - y for i in arr if i - y >= 1]
	if len(arr) > 0:
		print(*arr)
	else:
		print(-1)
(y, k, n) = map(int, input().split())
potatoes(y, k, n)


(y, k, n) = map(int, input().split())
print(' '.join(map(str, range(y // k * k + k - y, n - y + 1, k))) if n // k > y // k else -1)


(y, k, n) = map(int, input().split())
x = k - y % k
count = 0
while x + y <= n:
	print(x, end=' ')
	count += 1
	x += k
if count == 0:
	print('-1')


(y, k, n) = map(int, input().split())
if n / k < 1 or n <= y:
	print(-1)
	exit()
lim2 = n // k
lim1 = y // k
flag = 0
for i in range(lim1 + 1, lim2 + 1, 1):
	flag = 1
	print(k * i - y, end=' ')
if flag == 0:
	print(-1)


(y, k, n) = map(int, input().split())
if y >= n:
	print(-1)
else:
	m = n - y
	res = []
	p = 0
	for i in range(k, n + 1, k):
		if i > y:
			res.append(i - y)
	if len(res) == 0:
		print(-1)
	else:
		print(*res)


i = input().split()
(y, k, n) = (int(i[0]), int(i[1]), int(i[2]))
ans = ''
start = k - y % k
for i in range(start, n - y + 1, k):
	ans += str(i) + ' '
if len(ans) > 0:
	print(ans)
else:
	print(-1)


(y, k, n) = map(int, input().split())
if y >= n:
	print(-1)
else:
	i = 1
	t = k
	while k <= y:
		k += t
	if k > n:
		print('-1')
		quit()
	while k <= n:
		print(k - y, end=' ')
		k += t


import math
inputs = [int(x) for x in input().split()]
y = inputs[0]
k = inputs[1]
n = inputs[2]
result = ''
x = k - y % k
i = x
while i + y <= n:
	result += str(i) + ' '
	i += k
if len(result):
	print(result[0:len(result) - 1])
else:
	print('-1')


import io
import os

def main():
	(y, k, n) = map(int, input().split())
	x = k - y % k
	res = []
	while x + y <= n:
		res.append(x)
		x += k
	print(' '.join(map(str, res)) if res else -1)
main()


(y, k, n) = map(int, input().split())
x = k - y % k
if y + x > n:
	print(-1)
else:
	while x + y <= n:
		print(x, end=' ')
		x = x + k


(y, k, n) = map(int, input().split())
start = y + (k - y % k)
l = []
for i in range(start, n + 1, k):
	l.append(i)
if len(l):
	for x in l:
		print(x - y)
else:
	print(-1)


def read_input():
	input_str = str(input())
	return map(int, input_str.split(' '))

def find():
	(y, k, n) = read_input()
	max_x = n + 1 - y
	min_x = k - y % k
	result = list()
	for i in range(min_x, max_x, k):
		if (i + y) % k == 0 and i + y > 0:
			result.append(i)
	if len(result) == 0:
		result.append(-1)
	print(' '.join(map(str, result)))
find()


w = list(map(int, input().split()))
x = w[0]
divide = w[1]
divide1 = w[1]
sum = w[2]
y = 1
i = 0
ans = []
while x + y <= sum and divide <= sum:
	if divide - x > 0:
		ans += [divide - x]
		divide += divide1
		y = divide - x
	else:
		divide += divide1
if len(ans) == 0:
	ans += [-1]
i = 0
while i < len(ans):
	print(ans[i], end=' ')
	i += 1


A = list(map(int, input().split(' ')))
y = A[0]
k = A[1]
n = A[2]
x = y + k - y % k
ans = []
for i in range(x, n + 1, k):
	ans.append(i - y)
if len(ans) == 0:
	print(-1)
else:
	print(*ans)


(y, k, n) = map(int, input().split())
candidates = [str(x) for x in range(k - y, n // k * k - y + 1, k) if x > 0]
if candidates:
	print(' '.join(candidates))
else:
	print(-1)


(y, k, n) = map(int, input().split())
cc = k
ans = []
while 1:
	if cc > n:
		break
	x = cc - y
	if x > 0:
		ans.append(x)
	cc += k
if len(ans) == 0:
	print(-1)
else:
	for i in ans:
		print(i, end=' ')
	print()


iarr = list(map(int, input().split()))
y = iarr[0]
k = iarr[1]
n = iarr[2]
posx = -y % k
if posx == 0:
	i = 1
else:
	i = 0
ans = []
while k * i + posx + y <= n:
	ans.append(k * i + posx)
	i += 1
if ans == []:
	print(-1)
else:
	for i in ans:
		print(i, end=' ')
	print()


from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
from bisect import bisect_left
from bisect import bisect_right

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

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

def I():
	return int(stdin.readline())
P = 1000000007

def main():
	(y, k, n) = In()
	arr = []
	for i in range((y // k + 1) * k, n + 1, k):
		arr.append(i - y)
	if len(arr):
		print(*arr)
	else:
		print(-1)
main()


s = [int(n) for n in input().split()]
n = 1
l = 0
while 1:
	if s[1] * n - s[0] > 0 and s[1] * n <= s[2]:
		print(s[1] * n - s[0], end=' ')
		l = 1
	elif s[1] * n > s[2]:
		break
	n += 1
if l == 0:
	print(-1)


(y, k, n) = [int(i) for i in input().split()]
z = y
y = k - y % k
if y + z > n:
	print(-1)
else:
	while (z + y) % k == 0 and y + z <= n:
		print(y, end=' ')
		y += k


def solve():
	(y, k, n) = list(map(int, input().split(' ')))
	inc = k - y % k
	arr = [i for i in range(inc, n - y + 1, k)]
	if len(arr) == 0:
		print(-1)
	else:
		print(*arr)
	return
solve()


(y, k, n) = map(int, input().split())
if n - y == 0:
	print(-1)
else:
	y1 = y
	res = []
	(f, f1) = (0, 0)
	while y <= n:
		if not y % k:
			f = 1
			if y - y1:
				f1 = 1
				print(y - y1, end=' ')
		if not f:
			temp = y // k + 1
			y = k * temp
		else:
			y += k
	if not f1:
		print(-1)


s = input('')
(y, k, n) = s.split(' ')
y = int(y)
k = int(k)
n = int(n)
val = n - y
l = []
temp = val
z = y // k
while True:
	z += 1
	temp1 = k * z
	x = temp1 - y
	if x <= temp and x >= 1:
		l.append(x)
	else:
		break
if len(l) == 0:
	print('-1')
else:
	for i in l:
		print(i, end=' ')


from math import *

def main():
	(y, k, n) = map(int, input().split())
	z = k - y % k
	if y + z > n:
		print(-1)
		return
	arr = []
	x = k - y % k
	while x + y <= n:
		arr.append(x)
		x += k
	print(' '.join(map(str, arr)))
main()


(y, k, n) = map(int, input().split())
solution = []
min_quotient = (y + 1) // k
max_quotient = n // k
for quotient in range(min_quotient, max_quotient + 1):
	x = quotient * k - y
	if x >= 1:
		solution.append(repr(x))
if solution:
	print(' '.join(solution))
else:
	print(-1)


(y, k, n) = input().split()
y = int(y)
k = int(k)
n = int(n)
l = []
t = k * int(n / k)
x = t - y
while x > 0:
	l.append(x)
	x -= k
if len(l) == 0:
	print(-1, end='')
for i in range(len(l) - 1, -1, -1):
	print(l[i], end=' ')
print()


(y, k, n) = map(int, input().split())
r = k - y % k
m = n - y
if r <= m:
	print(r, end=' ')
	r = r + k
	while r <= m:
		print(r, end=' ')
		r += k
else:
	print(-1)


(y, k, n) = map(int, input().split())
if y >= n:
	print('-1')
else:
	s = set()
	e = []
	x = k - y % k
	while True:
		if x + y <= n:
			s.add(x)
			x = x + k
		else:
			break
	for ele in s:
		e.append(ele)
	e.sort()
	if len(e) > 0:
		print(*e)
	else:
		print('-1')


(y, k, n) = map(int, input().split())
s = ''
for i in range(y // k + 1, n // k + 1):
	s += str(k * i - y) + ' '
if s == '':
	print(-1)
else:
	print(s)


(y, k, n) = map(int, input().split())
t = y
t = t - t % k
t = t + k
c = 0
while t <= n:
	c = 1
	print(t - y, end=' ')
	t = t + k
if c == 0:
	print(-1)


(y, k, n) = map(int, input().split())
s = -y % k
if s > n - y or (s == 0 and s + k > n - y):
	print(-1)
else:
	while s <= n - y:
		if s > 0:
			print(s)
		s += k


(y, k, n) = map(int, input().split())
x = k - y % k
if x + y > n:
	print(-1)
else:
	print(*range(x, n - y + 1, k))


(y, k, n) = map(int, input().split())
c = int(y // k) + 1
if y >= n or c * k not in range(y, n + 1):
	print(-1)
else:
	c = int(y // k) + 1
	arr = [x - y for x in range(c * k, n + 1, k)]
	print(*arr)


(y, k, n) = list(map(int, input().split()))
A = n // k * [0]
pos = 0
for i in range(1, n // k + 1):
	x = i * k - y
	if 1 <= x:
		A[pos] = x
		pos += 1
if pos == 0:
	print(-1)
else:
	print(' '.join(map(str, A[:pos])))


(y, k, n) = [int(x) for x in input().split(' ')]
answer = []
x = k - y % k
while x < n - y + 1:
	answer.append(str(x))
	x += k
if len(answer):
	print(' '.join(answer))
else:
	print('-1')


(y, k, n) = map(int, input().split())
ans = []
for i in range(1, n // k + 1):
	if i * k - y > 0:
		ans.append(i * k - y)
if len(ans) == 0:
	print(-1)
else:
	print(*ans)


[y, k, n] = [int(x) for x in input().split()]
if k > n:
	print('-1')
else:
	ans = k
	c = -1
	while ans <= n:
		if ans - y >= 1:
			print(str(ans - y), end=' ')
			c = 1
		ans += k
	if c == -1:
		print(c)


ykn = list(map(int, input().strip().split()))
y = ykn[0]
k = ykn[1]
n = ykn[2]
while True:
	x = k - y % k
	if x + y <= n:
		val = True
		for i in range(x, n - y + 1, k):
			print(i, end=' ')
		break
	else:
		print(-1)
		break


(y, k, n) = map(int, input().split())
p = False
for i in range(k, n + 1, k):
	if i > y:
		print(i - y, end=' ')
		p = True
if p == False:
	print(-1)
else:
	print()


import sys, os
from math import sqrt, gcd, ceil, log, floor, sin, pi
from math import factorial as fact
from bisect import bisect, bisect_left
from collections import defaultdict, Counter, deque
from heapq import heapify, heappush, heappop
from itertools import permutations
input = sys.stdin.readline
read = lambda : list(map(int, input().strip().split()))
read_f = lambda : list(map(float, input().strip().split()))
MOD = 10 ** 9 + 7

def f(arr):
	for i in range(len(arr) - 1):
		if arr[i] == arr[i + 1]:
			return False
	return True

def main():
	(y, k, n) = read()
	arr = []
	s = 0
	while s + k <= n:
		s += k
		if s > y:
			arr.append(s - y)
	if arr:
		print(*arr)
	else:
		print(-1)
main()


def twoPotatoes():
	(y, k, n) = map(int, input().split())
	i = 1
	l = []
	while k * i <= n:
		if k * i > y:
			break
		i = i + 1
	while k * i <= n:
		l.append(k * i - y)
		i += 1
	if len(l) == 0:
		print(-1)
		return
	else:
		print(*l)
twoPotatoes()


(y, k, n) = map(int, input().split())
if n - y <= 0 or k > n:
	print('-1')
else:
	while n - y >= 1 and n % k != 0:
		n -= 1
	if n - y <= 0:
		print('-1')
	else:
		ans = []
		while n - y >= 1:
			ans.append(n - y)
			n = n - k
		ans = ans[::-1]
		n = len(ans)
		for i in range(n):
			print(ans[i], end=' ')


(y, k, n) = map(int, input().split())
a = k - y % k
c = 0
for i in range(a, n - y + 1, k):
	if i >= 1:
		print(i, end=' ')
		c += 1
if c == 0:
	print(-1)


(y, k, n) = map(int, input().split())

def sim(x):
	return (x + y) % k == 0
val = 0
works = []

def check(i):
	if i > y:
		works.append(str(i - y))
while val <= n:
	check(val)
	val += k
if len(works) == 0:
	print(-1)
else:
	print(' '.join(works))


(y, k, n) = [int(x) for x in input().split()]
l = []
m = k - y % k
a = 0
while m <= n - y:
	l.append(m)
	m += k
	a = 1
if a == 0:
	print(-1)
else:
	print(*l)


import math
(a, b, c) = map(int, input().split())
x = c - a
r = a % b
y = b - r
sum = 2
l = []
count = 0
s = ' '
if y > x:
	print(-1)
else:
	while y <= x:
		print(y, end=' ')
		y += b
	print()


(y, k, n) = list(map(int, input().split()))
ar = [k * x - y for x in range(y // k + 1, n // k + 1)]
if len(ar) == 0:
	print(-1)
else:
	print(*ar)


(y, k, n) = map(int, input().split())
x = n - y
if x < 1:
	print(-1)
	quit()
diff = k - y % k
ans = []
while True:
	if diff <= x:
		ans.append(diff)
	else:
		break
	diff += k
if len(ans) == 0:
	print(-1)
else:
	print(*ans)


import sys
f = sys.stdin
(y, k, n) = map(int, f.readline().strip().split())
if y >= n:
	first = -1
else:
	t = k
	while t <= y:
		t += k
	first = t - y
if first == -1:
	print(-1)
elif first + y > n:
	print(-1)
else:
	res = []
	for i in range(first, n + 1 - y, k):
		res.append(i)
	print(*res)


(y, k, n) = [int(i) for i in input().split()]
bs = n - y
done = False
for i in range(y // k + 1, n // k + 1):
	x = i * k - y
	done = True
	print(x, end=' ')
if not done:
	print(-1)


import sys

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

def iinput():
	return int(input())

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

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))
(y, k, n) = rinput()
ans = []
x_min = k * (y // k + 1) - y
for x in range(x_min, n - y + 1, k):
	ans.append(x)
if ans == []:
	print(-1)
else:
	print(*ans)


(y, k, n) = map(int, input().split())
if y + 1 > n:
	print(-1)
else:
	a = set()
	b = set()
	for i in range(0, n + 1, k):
		a.add(i)
	a = list(a)
	a = sorted(a)
	p = []
	for i in range(len(a)):
		l = a[i] - y
		if l > 0:
			p.append(l)
	if len(p) > 0:
		print(*p)
	else:
		print(-1)


(y, k, n) = map(int, input().split())
if n - y <= 0:
	print(-1)
else:
	l1 = []
	c = 0
	for i in range(k, n + 1, k):
		if i - y <= 0:
			continue
		else:
			c += 1
			print(i - y, end=' ')
	if c == 0:
		print(-1)


(y, k, n) = [int(i) for i in input().split()]
s = []
start = k - y % k
stop = n - y + 1
for i in range(start, stop, k):
	s += [i]
if len(s) > 0:
	print(' '.join(map(str, s)))
else:
	print(-1)


import math
(y, k, n) = list(map(int, input().split()))
l = [k * i - y for i in range(math.ceil((y + 1) / k), n // k + 1)]
if len(l) is 0:
	print(-1)
else:
	print(' '.join(map(str, l)))


(y, k, n) = map(int, input().split())
list1 = []
kk = k
for i in range(k, n + 1, kk):
	list1.append(i)
for i in range(len(list1)):
	list1[i] = list1[i] - y
f = 0
for i in range(len(list1)):
	if list1[i] >= 1:
		print(list1[i], end=' ')
		f = 1
if f == 0:
	print(-1)


(y, k, n) = list(map(int, input().split()))
mx = n - y + 1
fx = (y // k + 1) * k - y
if fx < mx:
	for x in range(fx, mx, k):
		print(x, end=' ')
	print()
else:
	print(-1)


(y, k, n) = list(map(int, input().split()))
if n <= y:
	print('-1')
else:
	count = 1
	mulcount = 0
	product = k
	while product <= y:
		count += 1
		product = k * count
	while product > y and product <= n:
		print(product - y, end=' ')
		mulcount += 1
		count += 1
		product = k * count
	if mulcount == 0:
		print('-1')


def two_bags():
	info = list(map(int, input().split()))
	multiples = [i for i in range(info[1], info[2] + 1, info[1])]
	possible = [x - info[0] for x in multiples if x > info[0]]
	if len(possible) == 0:
		print(-1)
	else:
		for valor in possible:
			print(valor, end=' ')
two_bags()


(y, k, n) = map(int, input().split())
j = y // k + 1
if j * k > n:
	print(-1)
	exit()
while k * j <= n:
	print(k * j - y, end=' ')
	j += 1


(y, k, n) = [int(x) for x in input().split()]
x = k - y % k
upper = n - y
if x <= upper:
	print(x, end=' ')
	x += k
	while x <= upper:
		print(x, end=' ')
		x += k
else:
	print('-1')


(y, k, n) = map(int, input().split())
x = 1
c = 0
i = 0
while i + k <= n:
	i += k
	if i - y > 0:
		c = 1
		print(i - y, end=' ')
if c == 0:
	print(-1)


(y, k, n) = map(int, input().split())
a = (k - y % k) % k
if a == 0:
	a += k
flag = False
while a + y <= n:
	print(a, end=' ')
	flag = True
	a += k
if not flag:
	print(-1)


(y, k, n) = map(int, input().split(' '))
r = y % k
nxt = k - y % k
ans = []
for i in range(y + nxt, n + 1, k):
	ans.append(str(i - y))
if len(ans) == 0:
	print(-1)
else:
	print(' '.join(ans))


from collections import *

def main():
	(y, k, n) = read_ints()
	A = []
	x0 = (y + k) // k * k - y
	A = [x for x in range(x0, n - y + 1, k)]
	if len(A) == 0:
		print(-1)
	else:
		print_nums(A)
MOD = 998244353
import os
import sys
from io import BytesIO, IOBase
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 read_int():
	return int(input())

def read_ints():
	return list(map(int, input().split()))

def print_nums(nums):
	print(' '.join(map(str, nums)))

def YES():
	print('YES')

def Yes():
	print('Yes')

def NO():
	print('NO')

def No():
	print('No')

def fib(n):
	(a, b) = (0, 1)
	for _ in range(n):
		(a, b) = (b, a + b)
	return a

def fib_ns(n):
	assert n >= 1
	f = [0 for _ in range(n + 1)]
	f[0] = 0
	f[1] = 1
	for i in range(2, n + 1):
		f[i] = f[i - 1] + f[i - 2]
	return f

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

def xgcd(a, b):
	(x0, x1, y0, y1) = (0, 1, 1, 0)
	while a != 0:
		((q, a), b) = (divmod(b, a), a)
		(y0, y1) = (y1, y0 - q * y1)
		(x0, x1) = (x1, x0 - q * x1)
	return (b, x0, y0)

def modinv(a, m):
	(g, x, _) = xgcd(a, m)
	if g != 1:
		raise Exception('gcd(a, m) != 1')
	return x % m

def mod_add(x, y):
	x += y
	while x >= MOD:
		x -= MOD
	while x < 0:
		x += MOD
	return x

def mod_mul(x, y):
	return x * y % MOD

def mod_pow(x, y):
	if y == 0:
		return 1
	if y % 2:
		return mod_mul(x, mod_pow(x, y - 1))
	p = mod_pow(x, y // 2)
	return mod_mul(p, p)

def mod_inv(y):
	return mod_pow(y, MOD - 2)

def mod_div(x, y):
	return mod_mul(x, mod_inv(y))
main()


s = input().split(' ')
num = []
for i in s:
	num.append(int(i))
ans = ''
k = 0
while k <= num[2]:
	if k - num[0] > 0:
		ans += str(k - num[0])
		ans += ' '
	k += num[1]
if len(ans) == 0:
	print(-1)
else:
	print(ans[:-1])


(y, k, n) = map(int, input().split())
val = n - y
a = k - y % k
b = False
while a <= val:
	if val == 0:
		break
	print(a, end=' ')
	a += k
	b = True
if b == False:
	print('-1')


(y, k, n) = map(int, input().split())
r = n % k
u = n - r - y
q = []
while u > 0:
	q.append(u)
	u = u - k
if len(q) == 0:
	print(-1)
else:
	s = q[::-1]
	print(*s)


inp = input().split(' ')
y = int(inp[0])
k = int(inp[1])
n = int(inp[2])
s = []
b = y + (k - y % k)
for i in range(b, n + 1, k):
	if i > 0:
		s.append(str(i - y))
if len(s) == 0:
	print('-1')
else:
	print(' '.join(s))


data = input().split()
(Y, K, N) = (int(data[0]), int(data[1]), int(data[2]))
answer = []
i = K
while i <= N:
	if i > Y:
		answer.append(i - Y)
	i += K
if len(answer) == 0:
	print('-1')
else:
	print(' '.join(map(str, answer)))


(b, k, n) = map(int, input().split())
u = k - b % k
if u + b > n:
	print(-1)
else:
	for x in range(u, n - b + 1, k):
		print(f'{x} ', end='')


def potatoes_bags(y, k, n):
	s = ' '.join(map(str, range(k - y % k, n - y + 1, k)))
	return s if s else -1
(y, k, n) = map(int, input().split())
print(potatoes_bags(y, k, n))


(y, k, n) = [int(x) for x in input().split()]
b = False
for i in range(1, n + 1):
	if i * k > n:
		break
	else:
		x = i * k - y
		if x >= 1:
			b = True
			print(x, end=' ')
if b == False:
	print(-1)
else:
	print()


(y, k, n) = str(input()).split()
y = int(y)
k = int(k)
n = int(n)
res = list()
head = y // k
tail = n // k
for i in range(head, tail + 1):
	v = i * k
	if y < v <= n:
		res.append(str(v - y))
if len(res) > 0:
	print(' '.join(res))
else:
	print(-1)


(y, k, n) = map(int, input().split())
z = y // k * k
flag = 0
if y >= n or k > n:
	print(-1)
else:
	while z <= n:
		if z <= y:
			z += k
		else:
			flag = 1
			print(z - y, end=' ')
			z += k
	if flag == 0:
		print(-1)


def foo():
	inp = input()
	(y, k, n) = inp.split()
	y = int(y)
	k = int(k)
	n = int(n)
	count = y // k
	count += 1
	cur = count * k
	if cur > n:
		print(-1)
	while cur <= n:
		print(cur - y, end=' ')
		cur += k
foo()


(y, k, n) = list(map(int, input().split()))
l = []
i = 1
if y >= n:
	print(-1)
else:
	f = k - y % k
	l = []
	while f + y <= n:
		l.append(f)
		f = f + k
	if len(l) == 0:
		print(-1)
	else:
		for i in range(len(l) - 1):
			print(l[i], end=' ')
		print(l[len(l) - 1])


(y, k, n) = map(int, input().split())
ans = []
from math import ceil
x = ceil(y / k) * k - y
if x < 1:
	x += k
while x + y <= n:
	ans.append(x)
	x += k
if not ans:
	print(-1)
else:
	print(' '.join([str(i) for i in ans]))


(y, k, n) = map(int, input().split(' '))
r = n - y
rem = k - y % k
li = [rem for rem in range(rem, r + 1, k)]
if not li:
	print('-1')
else:
	for x in li:
		print(x, end=' ')


(y, k, n) = map(int, input().split())
t = y // k
l = []
i = t + 1
while i * k <= n:
	l.append(i * k - y)
	i += 1
if l:
	for i in l:
		print(i, end=' ')
else:
	print(-1)


(y, k, n) = [int(x) for x in input().split()]
ans = []
for s in range(k, n + 1, k):
	if s - y >= 1:
		ans.append(str(s - y))
if len(ans) > 0:
	print(' '.join(ans))
else:
	print(-1)


(y, k, n) = map(int, input().split())
ans = []
qaq = -y
while 1:
	if qaq > n - y:
		break
	if qaq >= 1:
		ans.append(qaq)
	qaq += k
if len(ans) == 0:
	print(-1)
ans = [str(i) for i in ans]
print(' '.join(ans))


import math

def function(y, k, n):
	l = []
	if k == 1:
		c = abs(n - y)
		if y >= n:
			print(-1)
		if y < n:
			for i in range(1, 10 ** 9):
				c = y + i
				if c > n:
					print(*l)
					break
				l.append(i)
	if k != 1:
		for i in range(1, 10 ** 12):
			if k * i > y and k * i <= n:
				l.append(k * i - y)
			if k * i > n:
				break
		if len(l) == 0:
			print(-1)
		if len(l) >= 1:
			print(*l)
(y, k, n) = map(int, input().rstrip().split())
function(y, k, n)


mod = 10 ** 9 + 7
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
(y, k, n) = list(map(int, input().split()))
ans = n - n % k - y
if ans > 0:
	for i in range(ans % k, ans + 1, k):
		if i != 0:
			print(i, end=' ')
else:
	print(-1)


def main():
	(y, k, n) = map(int, input().split())
	x = -y % k
	if not x:
		x = k
	res = list(range(x, n - y + 1, k))
	if not res:
		res.append(-1)
	print(' '.join(map(str, res)))
main()


import sys, math, bisect
inf = float('inf')
mod = 998244353

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

def gcd(a, b):
	return int(math.gcd(a, b))

def tobinary(n):
	return bin(n)[2:]

def binarySearch(a, x):
	i = bisect.bisect_left(a, x)
	if i != len(a) and a[i] == x:
		return i
	else:
		return -1

def lowerBound(a, x):
	i = bisect.bisect_left(a, x)
	if i:
		return i - 1
	else:
		return -1

def upperBound(a, x):
	i = bisect.bisect_right(a, x)
	if i != len(a) + 1 and a[i - 1] == x:
		return i - 1
	else:
		return -1

def primesInRange(n):
	ans = []
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	for p in range(2, n + 1):
		if prime[p]:
			ans.append(p)
	return ans

def primeFactors(n):
	factors = []
	while n % 2 == 0:
		factors.append(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			factors.append(i)
			n = n // i
	if n > 2:
		factors.append(n)
	return factors
from collections import deque, defaultdict, Counter
import heapq, string

def mults(k, n):
	mul = []
	x = k
	while k <= n:
		mul.append(k)
		k += x
	return mul
for _ in range(1):
	(y, k, n) = map(int, input().split())
	arr = mults(k, n)
	ans = []
	for i in arr:
		if i > y:
			ans.append(i - y)
	if ans == []:
		print(-1)
	else:
		print(*ans)


(y, k, n) = map(int, input().split())
res = []
i = y // k + 1
no = 0
while True:
	no = k * i
	if no > n:
		break
	res.append(no - y)
	i += 1
if len(res) > 0:
	print(*res)
else:
	print(-1)


(y, k, n) = [int(x) for x in input().split(' ')]
x = k - y % k
flag = 0
while x + y <= n:
	print(x)
	flag = 1
	x += k
if not flag:
	print(-1)


(y, k, n) = map(int, input().split())
tr = True
for i in range(k - y % k, n - y + 1, k):
	print(i)
	tr = False
if tr:
	print(-1)


(y, k, n) = map(int, input().split())
add = k - y % k
y = y + add
if y > n:
	print(-1)
	exit()
iters = (n - y) // k + 1
for i in range(iters):
	print(add, end=' ')
	add += k


(y, k, n) = map(int, input().split())
ans = []
i = 0
while True:
	if k * i > n:
		break
	if k * i > y and k * i <= n:
		ans.append(k * i - y)
	i += 1
if not ans:
	print(-1)
	exit()
print(*ans)


(y, k, n) = map(int, input().split())
flag = 0
for i in range(0, n + 1, k):
	x = i - y
	if x > 0:
		print(x, end=' ')
		flag = 1
if flag == 0:
	print(-1)


(y, k, n) = map(int, input().strip().split(' '))
lst = []
if k > n or y > n:
	print('-1')
else:
	p = y // k
	s = (p + 1) * k
	while s <= n:
		lst.append(s - y)
		s += k
	if len(lst) == 0:
		print(-1)
	else:
		for j in range(len(lst)):
			print(lst[j], end=' ')


(y, k, n) = map(int, input().split())
r = [i - y for i in range(k, n + 1, k) if i > y]
if r:
	print(*r)
else:
	print(-1)


(Y, K, N) = map(int, input().split())
mod = Y % K
start = K - mod
A = [str(x) for x in range(start, N - Y + 1, K)]
print(' '.join(A) if A else -1)


(y, k, n) = map(int, input().split())
ctr = y + k - y % k
if ctr > n:
	print(-1)
while ctr <= n:
	print(ctr - y, end=' ')
	ctr += k


import sys
import math
import itertools
import collections

def getdict(n):
	d = {}
	if type(n) is list or type(n) is str:
		for i in n:
			if i in d:
				d[i] += 1
			else:
				d[i] = 1
	else:
		for i in range(n):
			t = ii()
			if t in d:
				d[t] += 1
			else:
				d[t] = 1
	return d

def cdiv(n, k):
	return n // k + (n % k != 0)

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

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

def li():
	return list(map(int, input().split()))

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

def wr(arr):
	return ' '.join(map(str, arr))

def revn(n):
	return int(str(n)[::-1])

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True
(y, k, n) = mi()
if n - y < 1:
	print(-1)
else:
	ans = []
	k0 = k - y % k
	for i in range(k0, n - y + 1, k):
		ans.append(i)
	if len(ans) < 1:
		print(-1)
	else:
		print(wr(ans))


(y, k, n) = map(int, input().split(' '))
lst = []
x = k - y % k
while x + y <= n:
	if (x + y) % k == 0:
		lst.append(x)
	x += k
if len(lst) == 0:
	print(-1)
else:
	print(' '.join(list(map(str, lst))))


(y, k, n) = [int(x) for x in input().split(' ')]
res = ''
for i in range(k - y % k, n - y + 1, k):
	res += str(i) + ' '
if res.strip() == '':
	print(-1)
else:
	print(res[:-1])


def two_bags():
	info = list(map(int, input().split()))
	k = info[1]
	posible = []
	while k <= info[2]:
		if k > info[0]:
			posible.append(k - info[0])
		k += info[1]
	if len(posible) == 0:
		print(-1)
	else:
		for valor in posible:
			print(valor, end=' ')
two_bags()


(y, k, n) = map(int, input().split())
if y % k == 0:
	a = y + k
else:
	b = y // k
	a = k * (b + 1)
flag = 0
while a <= n:
	print(a - y, end=' ')
	flag = 1
	a = a + k
if flag == 0:
	print('-1')


(y, k, n) = input().split()
(y, k, n) = (int(y), int(k), int(n))
c = 0
if y < k:
	x = k - y
else:
	x = k - y % k
if x == 0:
	x = k
while x <= n - y:
	c += 1
	print(x, end=' ')
	x += k
if c == 0:
	print(-1)


X = list(map(int, input().split()))
Answer = []
Remainder = X[1] - X[0] % X[1]
Diff = X[2] // X[1] - X[0] // X[1]
for i in range(Diff):
	Answer.append(str(Remainder + i * X[1]))
if len(Answer) == 0:
	print(-1)
else:
	print(' '.join(Answer))


(y, k, n) = map(int, input().split())
a = []
for i in range(k, n + 1, k):
	if i <= y:
		continue
	if i % k == 0:
		a.append(str(i - y))
print(-1 if len(a) == 0 else ' '.join(a))


(y, k, n) = [int(i) for i in input().split()]
up_limit = n // k
low_limit = y // k
ans = []
for i in range(low_limit, up_limit + 1):
	if n >= i * k and i * k - y > 0:
		ans.append(str(i * k - y))
if ans == []:
	print(-1)
else:
	print(' '.join(ans))


(y, k, n) = map(int, input().split())
mult = []
for i in range(k, n + 1, k):
	mult.append(i)
ans = []
for x in mult:
	if x > y:
		ans.append(x - y)
if ans == []:
	print(-1)
else:
	print(*ans)


(y, k, n) = map(int, input().split())
t = (y // k + 1) * k
al = []
while t <= n:
	al.append(t - y)
	t += k
if len(al) > 0:
	print(*al)
else:
	print(-1)


ykn = input().split()
y = int(ykn[0])
k = int(ykn[1])
n = int(ykn[2])
c = k - y % k
li = []
for i in range(c, n - y + 1, k):
	li.append(i)
if len(li) == 0:
	print(-1)
else:
	for i in li:
		print(i, end=' ')


import sys, math
from collections import deque, defaultdict
import operator as op
from functools import reduce
from itertools import permutations
I = sys.stdin.readline

def ii():
	return int(I().strip())

def li():
	return list(map(int, I().strip().split()))

def mi():
	return map(int, I().strip().split())

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def valid(row, col, rows, cols, rcross, lcross):
	return rows[row] == 0 and cols[col] == 0 and (rcross[col + row] == 0) and (lcross[col - row] == 0)

def div(n):
	tmp = []
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			cnt = 0
			while n % i == 0:
				n = n // i
				cnt += 1
			tmp.append((i, cnt))
	if n > 1:
		tmp.append((n, 1))
	return tmp

def isPrime(n):
	if n <= 1:
		return False
	elif n <= 2:
		return True
	else:
		flag = True
		for i in range(2, int(n ** 0.5) + 1):
			if n % i == 0:
				flag = False
				break
		return flag

def s(b):
	ans = []
	while b > 0:
		tmp = b % 10
		ans.append(tmp)
		b = b // 10
	return ans

def main():
	(y, k, n) = mi()
	ans = []
	z = k
	while z <= n:
		if z - y > 0:
			ans.append(z - y)
		z += k
	if len(ans) == 0:
		print(-1)
	else:
		print(*ans)
main()


import math
(y, k, n) = map(int, input().split())
x = k * math.ceil(y / k) - y
if x == 0:
	x = k
i = 0
if y + x > n:
	print(-1)
else:
	while y + i * k + x <= n:
		print(i * k + x, end=' ')
		i += 1


(y, k, n) = [int(j) for j in input().split()]
v = []
c = n
i = c
while i >= k:
	if i % k == 0:
		if i - y > 0:
			v.append(i - y)
		i -= k
		continue
	i = i - int(i % k)
v.sort()
v = [str(i) for i in v]
v = ' '.join(v)
print(v if len(v) > 0 else '-1')


class CodeforcesTask239ASolution:

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

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

	def process_task(self):
		possible = []
		for x in range(self.y_k_n[1] - self.y_k_n[0] % self.y_k_n[1], self.y_k_n[2] - self.y_k_n[0] + 1, self.y_k_n[1]):
			possible.append(x)
		if possible:
			self.result = ' '.join([str(x) for x in possible])
		else:
			self.result = str(-1)

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


try:
	(y, k, n) = map(int, input().split())
	flg = 0
	if y >= n:
		print(-1)
	else:
		mult = 1
		while k * mult <= n:
			check = k * mult
			if check - y > 0:
				print(check - y, end=' ')
				flg = 1
				mult += 1
			else:
				mult += 1
		if flg == 0:
			print(-1)
except:
	pass


import math
import sys
import collections

def getdict(n):
	d = {}
	if type(n) is list:
		for i in n:
			if i in d:
				d[i] += 1
			else:
				d[i] = 1
	else:
		for i in range(n):
			t = ii()
			if t in d:
				d[t] += 1
			else:
				d[t] = 1
	return d

def cdiv(n, k):
	return n // k + (n % k != 0)

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

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

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)
(y, k, n) = mi()
r = []
for i in range(cdiv(y + 1, k), cdiv(n + 1, k)):
	r.append(k * i - y)
print(' '.join([str(x) for x in r])) if r else print(-1)


(y, k, n) = map(int, input().split())
x = k
lst = []
while x <= n:
	if x > y:
		lst.append(x - y)
	x += k
if len(lst) < 1:
	print(-1)
else:
	lst.sort()
	for ans in lst:
		print(ans, end=' ')


from sys import stdin, stdout
if not __debug__:
	stdin = open('input.txt', 'r')
tcs = int(stdin.readline()) if not __debug__ else 1
t = 1
while t <= tcs:
	(y, k, n) = map(int, stdin.readline().split())
	b = y // k + 1
	e = n // k + 1
	if b < e:
		for i in range(y // k + 1, n // k):
			print(k * i - y, end=' ')
		print(k * (n // k) - y)
	else:
		print(-1)
	t += 1


(y, k, n) = list(map(int, input().split()))
if y == k:
	count = 0
elif y > k:
	count = (y // k + 1) * k - y
else:
	count = k - y
if y >= n:
	print(-1)
elif y + count > n:
	print(-1)
else:
	while y + count <= n:
		if count == 0:
			count += k
			continue
		print(count, end=' ')
		count += k


from math import ceil
(y, k, n) = map(int, input().split())
m = ceil(y / k)
res = []
while 1:
	x = m * k - y
	if x + y > n:
		break
	if x >= 1:
		res.append(x)
	m += 1
if len(res) == 0:
	print('-1')
else:
	print(*res)


(y, k, n) = list(map(int, input().split()))
x = n - y
if x < 1:
	print(-1)
else:
	counter = 0
	for i in range(0, n + 1, k):
		if i - y > 0:
			counter += 1
			print(i - y, end=' ')
	if counter == 0:
		print(-1)


def solve():
	(y, k, n) = map(int, input().split())
	res = []
	start = y // k
	if k * start - y <= 0:
		start += 1
	end = n // k
	if k * end - y > n:
		end -= 1
	if start > end:
		print(-1)
		return
	for x in range(start, end + 1):
		res.append(k * x - y)
	print(*res)
solve()


import sys
import math
(y, k, n) = [int(x) for x in sys.stdin.readline().split()]
t = []
p = int(n / k)
z = p * k - y
if z <= 0:
	print(-1)
	return
t.append(str(z))
while z - k > 0:
	z -= k
	t.append(str(z))
print(' '.join(t[::-1]))


(y, k, n) = map(int, input().split())
x = (y // k + 1) * k - y
z = ' '.join(list(map(str, range(x, n - y + 1, k))))
print(z if z else -1)


(y1, k1, n1) = input().split()
y = int(y1)
k = int(k1)
n = int(n1)
b = 0
f = []
j = 0
x = k - y
l = n - y
if y < n:
	if k != y and k != n and (x >= 0):
		b = x
		while j < l:
			j = j + b
			c = j + y
			if c <= n:
				f.append(j)
			j += k - b
		h = len(f)
		if h == 0 or f[0] == 0:
			print('-1')
		elif h > 0:
			print(*f)
	elif k != y and k != n and (x < 0):
		while True:
			if x > 0:
				break
			x += k
		b = x
		while j < l:
			j = j + b
			c = j + y
			if c <= n:
				f.append(j)
			j += k - b
		h = len(f)
		if h == 0 or f[0] == 0:
			print('-1')
		elif h > 0:
			print(*f)
	elif n == 2 * y and k != n and (x == 0):
		print(n - y)
	elif k == n:
		print(n - y)
	elif k > n:
		print('-1')
else:
	print('-1')


def main():
	(y, k, n) = [int(i) for i in input().split()]
	x = 0
	s = 0
	l = []
	while s <= n:
		if s % k == 0:
			s += k
			x = s - y
			if x > 0 and s <= n:
				l.append(x)
			pass
		else:
			x += 1
	print(*l) if len(l) > 0 else print(-1)
	return 0
main()


import sys
INF = 10 ** 20
MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
(y, k, n) = I()
if y == n:
	print(-1)
else:
	x = k - y % k
	if x == 0:
		x += k
	if x + y > n:
		print(-1)
	else:
		while x + y <= n:
			print(x, end=' ')
			x += k


(y, k, n) = map(int, input().split())
b = y // k
e = n // k
sw = 1
for i in range(b, e + 1):
	t = k * i - y
	if t > 0 and t < n:
		sw = 0
		print(t, end=' ')
if sw:
	print(-1, end='')
print()


(y, k, n) = map(int, input().strip().split(' '))
s = n - y
x = k - y % k
a = 0
while x <= s:
	print(x, end=' ')
	x = x + k
	a = 1
if a == 0:
	print(-1)


(y, k, n) = map(int, input().split())
flag = False
for i in range(k - y % k, n - y + 1, k):
	print(i, end=' ')
	flag = True
if not flag:
	print(-1)


div = []

def divisor(n, m):
	iii = 1
	while True:
		if m * iii > n:
			break
		else:
			div.append(m * iii)
		iii += 1
(n, a, b) = map(int, input().split())
divisor(b, a)
j = 0
ans = []
for j in range(len(div)):
	if div[j] - n > 0:
		ans.append(div[j] - n)
if len(ans) == 0:
	print(-1)
else:
	for i in range(len(ans)):
		print(ans[i])


(y, k, n) = [int(i) for i in input().split()]
x = k - y % k
if x + y > n:
	print(-1)
while x + y <= n:
	print(x, end=' ')
	x += k


def two_bags_of_potatoes(y_int: int, k_int: int, n_int: int) -> None:
	start_pos = max(2, k_int)
	x_plus_y_list = list(range(start_pos, n_int + 1, k_int))
	x_list = []
	for each in x_plus_y_list:
		x = each - y_int
		if x >= 1:
			x_list.append(x)
	if len(x_list) == 0:
		x_list.append(-1)
	print(*x_list)
(y, k, n) = list(map(int, input().split()))
two_bags_of_potatoes(y, k, n)


(y, k, n) = map(int, input().split())
a = 1
sol = False
while a * k <= n:
	if a * k > y:
		x = a * k - y
		print(x, end=' ')
		sol = True
	a += 1
if not sol:
	print(-1, end=' ')


(y, k, n) = map(int, input().split())
s = 1
l = []
while k * s <= n:
	if k * s - y > 0:
		l.append(k * s - y)
	s += 1
if l:
	print(*l)
else:
	print(-1)


(y, k, n) = [int(i) for i in input().split()]
border = n // k
flag = 0
for q in range(1, border + 1):
	x = k * q - y
	if x >= 1:
		print(x, end=' ')
		flag = 1
if not flag:
	print(-1)


def main():
	from sys import stdin, stdout
	(y, k, n) = map(int, stdin.readline().split())
	maxfact = n // k
	ans = []
	for fact in range(1, maxfact + 1):
		if k * fact - y > 0:
			ans.append(k * fact - y)
	if len(ans) == 0:
		stdout.write('-1\n')
		return
	for x in ans:
		stdout.write(str(x) + ' ')
	stdout.write('\n')
main()


a = [int(i) for i in input().split()]
b = range(a[2] + 1)
c = b[0::a[1]]
c = [i - a[0] for i in c]
c = [i for i in c if i > 0]
if c == []:
	print(-1)
else:
	print(' '.join([str(i) for i in c]))


(y, k, n) = map(int, input().split())
i = 1
temp = 0
while True:
	if k * i <= n and k * i > y:
		temp = 1
		print(abs(y - k * i), end=' ')
	elif k * i > n:
		break
	i += 1
if temp == 0:
	print(-1)


from math import ceil
(y, k, n) = [int(i) for i in input().split()]
if y >= n:
	print(-1)
else:
	results = []
	pos = ceil(y / k) * k - y
	if pos == 0:
		pos += k
	for x in range(pos, n - y + 1, k):
		results.append(x)
	if len(results) > 0:
		print(*results)
	else:
		print(-1)


def main():
	(y, k, n) = map(int, input().split())
	i = 1
	cnt = 0
	while i * k <= n:
		if i * k - y > 0:
			print(i * k - y, end=' ')
			cnt += 1
		i += 1
	if cnt == 0:
		print(-1)
main()


(y, k, n) = input().split()
(y, k, n) = [int(y), int(k), int(n)]
a = []
diff = n - y
i = k - y % k
a = []
while i <= diff:
	a.append(i)
	i += k
if len(a) == 0:
	print('-1')
else:
	print(*a, sep=' ')


(y, k, n) = (int(i) for i in input().split(' '))
noVal = True
i = int(y / k) + 1
while True:
	if k * i <= n:
		print(k * i - y, end=' ')
	else:
		break
	i += 1
	noVal = False
if noVal == True:
	print(-1)


(x, y, z) = [int(x) for x in input('').split()]
z = z - z % y - x
l = []
if z > 0:
	l.append(z)
	while z > y:
		z = z - y
		l.append(z)
	l.reverse()
	print(*l)
else:
	print(-1)


(y, k, n) = map(int, input().strip().split())
t = 0
kk = 0
while t <= n:
	z = (t + y) % k
	t = t + (k - z)
	if t + y > n:
		break
	else:
		kk += 1
		print(abs(t), end=' ')
if kk == 0:
	print(-1)


(chips, divisor, maximum) = map(int, input().split())
first = divisor - chips % divisor
if first + chips > maximum:
	print(-1)
else:
	print(first)
	while chips + first <= maximum - divisor:
		first += divisor
		print(first)


from sys import stdin as sin

def gint():
	return int(sin.readline())

def gmap():
	return map(int, sin.readline().split())

def glist():
	return list(map(int, sin.readline().split()))

def gstr():
	return sin.readline()
from math import ceil
(y, k, n) = gmap()
i = int(ceil(y / k))
f = True
for j in range(i * k - y, n, k):
	if j + y > n:
		break
	if j != 0:
		f = False
		print(j, end=' ')
if f:
	print(-1)


line = list(map(int, input().split()))
(y, k, n) = line
ans = []
for i in range(0, n + 1, k):
	if i > y and i <= n:
		ans.append(str(i - y))
if ans:
	print(' '.join(ans))
else:
	print('-1')


(n, k, t) = map(int, input().rstrip().split(' '))
l = []
if n < k:
	s = k - n
elif n == k:
	s = 0
elif n > k:
	if n % k:
		s = (n // k + 1) * k - n
	else:
		s = 0
end = t - n
while s <= end:
	if s != 0:
		l.append(s)
	s = s + k
if not l:
	print(-1)
else:
	print(*l)


(y, k, n) = input().split()
check = False
(y, k, n) = [int(y), int(k), int(n)]
if y >= k:
	a = k - y % k
	for i in range(a, n, k):
		if i + y <= n:
			print(i, end=' ')
			check = True
		else:
			break
elif y < k:
	a = k - y
	for i in range(a, n, k):
		if i + y <= n:
			check = True
			print(i, end=' ')
		else:
			break
if check == False:
	print('-1')


(y, k, n) = map(int, input().split())
i = y // k * k + k
found = False
while True:
	if i > n:
		break
	print(i - y, end=' ')
	found = True
	i += k
if not found:
	print(-1)


arr = list(map(int, input().split(' ')))
y = arr[0]
k = arr[1]
n = arr[2]
max_x = n - y
if max_x <= 0:
	print(-1)
else:
	str1 = ''
	i = 1
	while True:
		temp = k * i - y
		if temp > 0:
			if temp <= max_x:
				str1 += str(temp)
				str1 += ' '
			else:
				break
		i += 1
	if len(str1) == 0:
		print(-1)
	else:
		print(str1)


import sys
inf = float('inf')
from math import ceil, floor, log, sqrt, factorial, pi, gcd

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()
(y, k, n) = get_ints()
lst = []
if y % k == 0:
	first = k
else:
	first = ceil(y / k) * k - y
while y + first <= n:
	lst.append(first)
	first += k
if len(lst) == 0:
	print(-1)
else:
	print(*lst)


(a, b, c) = map(int, input().split(' '))
i = a // b + 1
if i * b > c:
	print(-1)
	exit()
while i * b <= c:
	print(b * i - a)
	i += 1


import math, sys
from collections import Counter

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

def ls():
	return list(map(int, list(input())))

def la():
	return list(input())

def i():
	return int(input())

def isPrime(n):
	i = 2
	if n == 1:
		return False
	while i <= int(math.sqrt(n)):
		if n % i == 0:
			return False
		i = i + 1
	return True

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
(y, k, n) = li()
a = n // k
b = []
i = 0
if n > y:
	while i <= a:
		x = i * k - y
		if x > 0 and x <= n - y:
			b.append(x)
		i = i + 1
if b == []:
	print(-1)
else:
	print(*b)


(y, k, n) = map(int, input().split())
flag = True
init = (y + k) % k
init = y + k - init
for x in range(init, n + 1, k):
	flag = False
	print(x - y, end=' ')
if flag:
	print(-1)


(y, k, n) = map(int, input().split(' '))
x = k - y % k
t = ''
while x + y <= n:
	t += str(x) + ' '
	x += k
if len(t) == 0:
	print(-1)
else:
	print(t[0:len(t) - 1])


(y, k, n) = map(int, input().split())
x = k - y % k
maxm = n - y
l = []
if x <= maxm:
	while x <= maxm:
		l.append(x)
		x += k
	print(*l)
else:
	print(-1)


(y, k, n) = map(int, input().split())
printed = False
start = k - y % k
if start + y > n:
	print(-1)
else:
	for i in range(start, n, k):
		if i + y <= n:
			print(i, end=' ')


(y, k, n) = map(int, input().split())
f = (n - y - n % k) % k
if f == 0:
	f = k
if n - y < f:
	print(-1)
else:
	for i in range(f, n - y + 1, k):
		print(i)


(y, k, n) = map(int, input().split())
noAnswer = False
if y % k == 0:
	s = y + k
else:
	s = y + k - y % k
while s <= n:
	noAnswer = True
	print(s - y, end=' ')
	s += k
if not noAnswer:
	print(-1)


import sys, math
(y, k, n) = map(int, input().split(' '))
if y >= n:
	print(-1)
else:
	ans = 0
	i = math.ceil(y / k)
	while k * i <= n:
		if k * i - y == 0:
			i += 1
		if k * i <= n:
			print(k * i - y)
			ans += 1
		i += 1
	i = math.ceil(y / k)
	if ans == 0 or k * i > n:
		print(-1)


(y, k, n) = map(int, input().split())
boo = False
ans = []
for i in range(k, n + 1, k):
	if i > y:
		ans.append(i - y)
		boo = True
if boo:
	for i in ans:
		print(i, end=' ')
else:
	print(-1)


do_cf = False
import math
(a, b, c) = list(map(int, input().split(' ')))
x = math.floor(c / b)
dead = x * b
deaded = b * math.ceil(a / b)
strx = ''
for i in range(deaded, dead + 1, b):
	if i - a > 0:
		do_cf = True
		strx += ' ' + str(i - a)
if do_cf:
	print(strx)
else:
	print('-1')


(y, k, n) = [int(i) for i in input().split()]
for i in range(y // k + 1, n // k + 1):
	print(k * i - y, end=' ')
if y // k + 1 >= n // k + 1:
	print(-1)


def solve():
	(y, k, n) = map(int, input().split())
	L = [xy - y for xy in range(0, n + 1, k) if xy > y]
	if L:
		print(' '.join(map(str, L)))
	else:
		print(-1)
solve()


(y, k, n) = map(int, input().split())
temp = int(y / k)
temp += 1
temp = temp * k
if temp > n:
	print(-1)
	return
while temp <= n:
	print(temp - y, end=' ')
	temp += k
print()


(y, k, n) = map(int, input().split())
z = n // k
if n > y and k * z - y > 0:
	l = []
	for i in range(1, z + 1):
		if k * i - y > 0:
			l.append(str(k * i - y))
	print(' '.join(l))
else:
	print(-1)


(y, k, n) = map(int, input().split())
l = []
rem = y % k
if rem > 0 and k - rem + y <= n:
	l.append(k - rem)
elif rem == 0 and y + k <= n:
	l.append(k)
if len(l) == 0:
	print(-1)
	exit()
t = l[0]
maxm = n - y
while t + k <= maxm:
	t += k
	l.append(t)
print(*l)


a = input().split()
y = int(a[0])
k = int(a[1])
n = int(a[2])
xl = []
xf = -1
div = n // k
mul = div * k
xmax = mul - y
if xmax < 1:
	print(-1)
else:
	xl.append(xmax)
	while True:
		xmax -= k
		if xmax < 1:
			break
		xl.append(xmax)
	xl.sort()
	ans = ''
	for k in xl:
		ans += str(k) + ' '
	print(ans)


ar = []
for i in input().split(' '):
	ar.append(int(i))
res = []
temp = ar[0] // ar[1] + 1
temp = temp * ar[1]
if temp > ar[2]:
	print(-1)
else:
	while temp <= ar[2]:
		res.append(temp - ar[0])
		temp = temp + ar[1]
	print(*res)


from sys import stdin, stdout
ii1 = lambda : int(stdin.readline())
is1 = lambda : stdin.readline()
iia = lambda : map(int, stdin.readline().split())
isa = lambda : stdin.readline().split()
(y, k, n) = iia()
res = []
s = y // k + 1
e = n // k + 1
for i in range(s, e):
	res.append(i * k - y)
if len(res) == 0:
	print(-1)
else:
	print(*res)


(y, k, n) = map(int, input().split())
a = []
x = k - y % k
for i in range(x, n - y + 1, k):
	print(i, end=' ')
if x >= n - y + 1:
	print(-1)


(y, k, n) = list(map(int, input().split()))
ans = []
x = k - y % k
if x + y <= n:
	while x + y <= n:
		ans.append(x)
		x += k
	print(*ans)
else:
	print(-1)


(y, k, n) = map(int, input().split())
print(*(range((k - y) % k or k, n - y + 1, k) or (-1,)))


import sys, math, itertools, random, bisect
from collections import defaultdict
INF = sys.maxsize

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

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

def input():
	return sys.stdin.readline().strip()
mod = 10 ** 9 + 7
for _ in range(1):
	(y, k, n) = get_ints()
	if k > y:
		z = k - y
	elif k == y:
		z = k
	else:
		z = k - y % k
	if z + y > n:
		print(-1)
	else:
		while z + y <= n:
			print(z, end=' ')
			z += k
		print()


(y, k, n) = map(int, input().split())
l = []
q = y // k
rem = (q + 1) * k - y
x = rem
while x + y <= n:
	l.append(x)
	x += k
try:
	p = l[0]
	for i in l:
		print(i, end=' ')
except Exception as e:
	print(-1)


(y, k, n) = input().split()
y = int(y)
k = int(k)
n = int(n)
p = 0
x = 0
string = ''
while True:
	x = k * (p + 1) - y % k
	p += 1
	if x + y > n:
		break
	string += str(x) + ' '
if string == '':
	print('-1')
else:
	print(string)


(a, b, c) = map(int, input().split())
k = a % b
p = a
if k:
	p += b - k
exist = False
for i in range(p, c + 1, b):
	if i - a > 0:
		exist = True
		print('%d ' % (i - a), end='')
if exist == False:
	print('-1')


(y, k, n) = map(int, input().split())
x = k - y
r = 0
f = True
while x + y <= n:
	if 1 <= x:
		print(x, end=' ')
		f = False
	x += k
if f:
	print(-1, end=' ')
print()


import math as m
(y, k, n) = map(int, input().split())
if y == n:
	print(-1)
else:
	res = []
	temp = (int(m.floor(y / k)) + 1) * k
	while temp <= n:
		res.append(temp)
		print(temp - y, end=' ')
		temp += k
	if len(res) == 0:
		print(-1)


(y, k, n) = [int(x) for x in input().split()]
first = (y // k + 1) * k
if first > n:
	print(-1)
	exit()
l = []
for x in range(first, n + 1, k):
	l.append(str(x - y))
print(' '.join(l))


import math
import collections

def cint():
	return list(map(int, input().split()))

def cstr():
	return list(map(str, input().split(' ')))

def solve():
	(y, k, n) = cint()
	if y >= n:
		print(-1)
		return
	else:
		x = k - y % k
		if x + y > n:
			print(-1)
			return
		while x + y <= n:
			print(x, end=' ')
			x += k
t = 1
while t != 0:
	solve()
	t -= 1


import math
(y, k, n) = map(int, input().split())
res = []
start = math.ceil((1 + y) / k)
end = math.floor(n / k)
for i in range(start, end + 1):
	res.append(i * k - y)
if len(res) == 0:
	print('-1')
else:
	for num in res:
		print(num, end=' ')


line = input()
(y, k, n) = [int(i) for i in line.split()]
ans = y + (k - y % k)
vet = []
for i in range(ans, n + 1, k):
	vet.append(i)
if len(vet):
	for x in vet:
		print(x - y, end=' ')
else:
	print(-1)


import sys
from math import *
input = sys.stdin.readline
RI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
rw = lambda : input().strip().split()
ls = lambda : list(input().strip())
from collections import defaultdict as df
import heapq
infinite = float('inf')
(y, k, n) = RI()
l = []
for i in range(k, n + 1, k):
	if i % k == 0:
		if i - y >= 1:
			l.append(i - y)
if len(l) == 0:
	print(-1)
else:
	print(*l)


try:
	(y, k, n) = map(int, input().split())
	l = []
	if n <= y or n < k:
		print(-1)
	else:
		q = y // k
		q = q + 1
		while k * q <= n:
			l.append(k * q - y)
			q = q + 1
		if len(l) == 0:
			print(-1)
		else:
			print(*l)
except Exception:
	pass


def run():
	import sys
	sys.stdin = open('/home/puneet/Documents/Cpp Programs/input.txt', 'r')
	sys.stdout = open('/home/puneet/Documents/Cpp Programs/output.txt', 'w')
	from math import ceil, sqrt, floor
(y, k, n) = map(int, input().split())
s = set()
if y >= n:
	print(-1)
else:
	for i in range(k, n + 1, k):
		if i - y > 0:
			s.add(i - y)
	if len(s) == 0:
		print(-1)
	else:
		s = list(s)
		s.sort()
		print(*s)


(y, k, n) = list(map(int, input().split()))
p = k - y % k
p = max(p, 1)
l1 = []
for i in range(y + p, n + 1, k):
	l1.append(i - y)
if l1 == []:
	print(-1)
else:
	print(*l1)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

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

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

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

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def main():
	(y, k, n) = LI()
	t = y + (k - y % k)
	if t == y:
		t += k
	r = list(range(t - y, n - y + 1, k))
	if len(r) < 1:
		return -1
	return JA(r, ' ')
print(main())


a = input()
y = int(a.split(' ')[0])
k = int(a.split(' ')[1])
n = int(a.split(' ')[2])
ans = []
a = 0
b = 0
a = k - y % k
b = (max(y, n) - min(y, n)) // k
if y >= n or k > n:
	ans.append(-1)
elif y == 1:
	b = b + 1
if k == n and n - y > 0:
	ans.append(n - y)
if len(ans) == 0:
	for i in range(b):
		if a < n:
			ans.append(a)
			a = a + k
	if b == 0:
		if n - y % k == y:
			ans.append(y % k)
		else:
			ans.append(-1)
	if n - (ans[-1] + y) >= k and ans[-1] < n and (ans[0] != -1):
		ans.append(ans[-1] + k)
print(*ans, sep=' ')


(y, k, n) = map(int, input().split())
if k > n:
	print(-1)
else:
	m = y % k
	m = k - m
	ct = 0
	for i in range(m, n + 1, k):
		if i + y > n:
			break
		ct += 1
		print(i, end=' ')
	if ct == 0:
		print(-1)


(y, k, n) = map(int, input().split())
a = []
z = n // k
b = 0
for i in range(1, z + 1):
	if k * i > y:
		a.append(k * i - y)
		b = 1
a.sort()
for i in a:
	print(i, end=' ')
if b == 0:
	print('-1')


def solve():
	(y, k, n) = map(int, input().split())
	if n <= y:
		print(-1)
		return
	else:
		x = 1
		z = []
		x = k - y % k
		while (x + y) % k == 0 and x + y <= n:
			z.append(x)
			x += k
		if len(z) == 0:
			print(-1)
			return
		print(*z)
try:
	solve()
except:
	pass


(y, k, n) = map(int, input().strip().split(' '))
i = int(y / k + 1)
l = []
x = int(n / k)
while i <= x:
	l.append(i * k - y)
	i += 1
if len(l) == 0:
	print(-1)
else:
	for i in l:
		print(i, end=' ')


(b, k, n) = map(int, input().split())
tot = (int(b / k) + 1) * k
a = 1
for i in range(tot, n + 1, k):
	print(i - b, end=' ')
	a = 0
if a == 1:
	print(-1)


while 1:
	try:
		(y, k, n) = map(int, input().split())
		start = y // k
		end = n // k
		if y >= n or start == end:
			print(-1)
		else:
			for i in range(start + 1, end + 1):
				print(k * i - y, end=' ')
			print('')
	except EOFError:
		break


import sys
(y, k, n) = map(int, sys.stdin.readline().split())
index = int(y / k) * k + k
x = 0
while index <= n:
	x = index - y
	index += k
	if x == 0:
		continue
	print(str(x) + ' ', end='')
if x == 0:
	print('-1')


def potatoes_bags(y, k, n):
	f = 0
	if y >= n:
		print(-1)
	else:
		m = (y + 1) % k
		if m:
			m = 1 + k - m
		else:
			m = 1
		while m <= n - y:
			f = 1
			print(m, end=' ')
			m += k
		if f == 0:
			print(-1)
(y, k, n) = map(int, input().split())
potatoes_bags(y, k, n)


(y, k, n) = map(int, input().split())
if n > y:
	x = n - y
else:
	x = n + 2 * k
while (x + y) % k != 0:
	x -= (x + y) % k
result = []
while x + y <= n and x > 0:
	result.append(x)
	x -= k
if result:
	result.sort()
	print(' '.join([str(j) for j in result]))
else:
	print(-1)


(y, k, n) = map(int, input().split())
f = []
x = k - y % k
while x < n - y + 1:
	f.append(str(x))
	x += k
if len(f):
	print(' '.join(f))
else:
	print('-1')


inp = list(map(int, input().split()))
(y, k, n) = inp
n -= n % k
end = n
start = y + (k - y % k)
if start > end:
	print(-1)
for i in range(start, end + 1, k):
	print(i - y, end=' ')


(y, k, n) = [int(i) for i in input().split()]
if y >= n:
	print(-1)
else:
	ans = []
	first = y + (k - y % k)
	if first > n:
		print(-1)
	while first <= n:
		ans.append(first - y)
		first += k
	print(*ans)


from functools import reduce
from operator import *
from math import *
from sys import *
setrecursionlimit(10 ** 7)
RI = lambda : list(map(int, input().split()))
RS = lambda : input().rstrip().split()
(y, k, n) = RI()
st = k - y % k
if st + y > n:
	print(-1)
else:
	while 1:
		if st + y > n:
			break
		print(st, end=' ')
		st += k


(y, k, n) = map(int, input().split())
ans = ''
mul = 1
while k * mul <= n:
	x = k * mul - y
	if x < 1:
		mul += 1
		continue
	ans += str(x) + ' '
	mul += 1
if len(ans) == 0:
	print(-1)
else:
	print(ans)


import sys
(y, k, n) = map(int, sys.stdin.readline().split())
string = ''
for i in range(k, n + 1, k):
	if i - y > 0:
		string += str(i - y) + ' '
if string == '':
	print(-1)
else:
	print(string.strip())


(y, k, n) = map(int, input().split())
if y >= n:
	print(-1)
else:
	i = 1
	x = []
	while k * i <= n:
		t = k * i
		if y < t:
			x.append(t - y)
		i = i + 1
	if len(x) > 0:
		print(' '.join((str(i) for i in x)))
	else:
		print(-1)


def main():
	(y, k, n) = [int(x) for x in input().split()]
	print(solve(y, k, n))

def solve(y, k, n):
	ini = k - y % k
	pos = n - y
	st = ''
	for num in range(ini, pos + 1, k):
		if pos - num < k:
			st += '{}'.format(num)
		else:
			st += '{} '.format(num)
	if not st:
		st = '-1'
	return st
main()


import math
(y, k, n) = map(int, input().split())
arr = []
start = math.ceil(y / k) * k
for i in range(start, n + 1, k):
	arr += [i - y]
if arr == []:
	print(-1)
elif arr == [0]:
	print(-1)
else:
	if arr[0] == 0:
		del arr[0]
	print(*arr)


(y, k, n) = map(int, input().strip().split())
r = n - y
lis = []
t = 0
if y % k == 0:
	t = k
else:
	t = k - y % k
while t + y <= n:
	lis.append(t)
	t += k
if len(lis) == 0:
	print('-1')
else:
	print(*lis)


(y, k, n) = map(int, input().split())
m = 1
flag = 0
while m <= n // k:
	if k * m - y >= 1:
		flag = 1
		print(k * m - y, end=' ')
	m += 1
if flag == 0:
	print(-1)


s = [int(i) for i in input().split()]
d = []
chck = s[1] - s[0] % s[1]
g = int(s[2] / s[1])
while chck + s[0] <= s[2]:
	d.append(str(chck))
	chck += s[1]
if len(d) == 0:
	print('-1')
else:
	print(' '.join(d))


(y, k, n) = [int(i) for i in input().split()]
a = y % k
m = []
for i in range(n):
	h = i * k - a
	num = h + y
	if num <= n:
		if h > 0:
			m.append(h)
	else:
		break
if len(m) > 0:
	print(*m)
else:
	print(-1)


def readln():
	return tuple(map(int, input().split()))
(y, k, n) = readln()
p = y // k + 1
if p * k > n:
	print(-1)
else:
	while p * k <= n:
		print(p * k - y)
		p += 1


import operator as op
import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from functools import reduce
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, gcd, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

def inp():
	return int(input())

def inlist():
	return list(map(int, input().split()))

def instr():
	s = input()
	return list(s[:len(s)])

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

def def_value():
	return 0
(y, k, n) = invr()
res = 0
l = int(ceil((y + 1) / k)) * k
while l <= n:
	print(l - y, end=' ')
	l += k
	res += 1
if res == 0:
	print(-1)


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()
(y, k, n) = get_ints()
st = (y // k + 1) * k
if st > n:
	print(-1)
else:
	while st <= n:
		print(st - y, end=' ')
		st = st + k


(y, k, n) = list(map(int, input().split()))
ok = False
for i in range(k, n + 1, k):
	if y < i:
		print(i - y)
		ok = True
if not ok:
	print(-1)


(y, k, n) = map(int, input().split())
res = 0
for i in range(k, n + 1, k):
	q = i - y
	if q <= n and q > 0:
		res = 1
		print(q, end=' ')
if not res:
	print(-1)


def gint():
	return int(input())

def gint_arr():
	return list(map(int, input().split()))

def gfloat():
	return float(input())

def gfloat_arr():
	return list(map(float, input().split()))

def pair_int():
	return map(int, input().split())
INF = 1 << 31
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]
(y, k, n) = gint_arr()
x = k - y % k
found = False
while x + y <= n:
	print(x, end=' ')
	x += k
	found = True
if not found:
	print(-1)


(y, k, n) = map(int, input().split())
if n <= y:
	print(-1)
	exit()
m = n // k
l = []
for i in range(1, m + 1):
	x = i * k - y
	if x > 0:
		l.append(x)
if len(l) < 1:
	print(-1)
else:
	print(*l)


(y, k, n) = [int(x) for x in input().split()]
l = []
if n - y < 1:
	print(-1)
	exit()
if k == 0:
	print(-1)
	exit()
i = 1
while i * k <= n:
	if k * i - y >= 1:
		l.append(k * i - y)
	i += 1
if l == []:
	print(-1)
else:
	print(*l)


from math import ceil

def solve(y, k, n):
	ret = []
	i = k - y % k
	if i == 0:
		i += k
	while i + y <= n:
		ret.append(str(i))
		i += k
	if len(ret) == 0:
		return ['-1']
	return ret
(y, k, n) = map(int, input().split())
print(' '.join(solve(y, k, n)))


import math
(y, k, n) = map(int, input().split())
number = k * (int(y / k) + 1) - y
if number < n - y + 1:
	for i in range(number, n - y + 1, k):
		print(i, end=' ')
else:
	print('-1')


def main():
	(y, k, n) = map(int, input().split())
	ans = []
	if y + k - y % k <= n:
		ans = [k - y % k]
	if not ans:
		print(-1)
		return
	while True:
		if y + ans[-1] + k <= n:
			ans.append(ans[-1] + k)
		else:
			break
	for i in ans:
		print(i, end=' ')
main()


(y, k, n) = map(int, input().split())
l = []
if n <= y or n < k:
	print(-1)
else:
	q = y // k
	q = q + 1
	while k * q <= n:
		l.append(k * q - y)
		q = q + 1
	if len(l) == 0:
		print(-1)
	else:
		print(*l)


(y, k, n) = map(int, input().split())
cnt = 0
for i in range(1, pow(10, 5) + 1):
	if i * k > n:
		break
	if i * k - y <= 0:
		continue
	print(i * k - y, end=' ')
	cnt += 1
if cnt == 0:
	print(-1)


def readInput():
	s = input().split()
	return list(map(int, s))

def solve(x, n, k):
	while x <= n:
		print(str(x), end=' ')
		x += k

def solution2(y, k, n):
	x = k - y % k
	n -= y
	if x > n:
		print(-1)
	else:
		solve(x, n, k)
a = readInput()
solution2(a[0], a[1], a[2])


(y, k, n) = map(int, input().split())
t = k - y % k
if n - y < t:
	print(-1)
else:
	s = 0
	while y + t + s * k <= n:
		print(t + s * k, end=' ')
		s += 1


(y, k, n) = list(map(int, input().split()))
X_es = []
for i in range(k, n + 1, k):
	if i - y >= 1:
		X_es.append(i - y)
if len(X_es) != 0:
	for x in X_es:
		print(x)
else:
	print(-1)


import math
string = input()
(a, b, c) = map(int, string.split())
(p, q) = (math.ceil((a + 1) / b) * b, c // b * b)
if p > c:
	print(-1)
else:
	for x in range(p, q + 1, b):
		print(x - a, end=' ')


import os
import sys
from io import BytesIO, IOBase
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')
import math

def fact(x):
	if x == 0:
		return 1
	else:
		return x * fact(x - 1)

def lower_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] >= num:
			answer = middle
			end = middle - 1
		else:
			start = middle + 1
	return answer

def upper_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] <= num:
			answer = middle
			start = middle + 1
		else:
			end = middle - 1
	return answer

def binary_search(lb, ub, val, cnt):
	mid = (lb + ub) // 2
	if val < mid:
		ub = mid - 1
		binary_search(lb, ub, val, cnt - 1)
	elif val > mid:
		lb = mid + 1
		binary_search(lb, ub, val, cnt - 1)
	else:
		print(cnt)

def abs(x):
	return x if x >= 0 else -x
for t in range(1):
	(y, k, n) = list(map(int, input().split()))
	flag = 0
	for i in range(1, n // k + 1):
		x = i * k - y
		if x >= 1:
			flag = 1
			print(x, end=' ')
	if flag == 0:
		print(-1)


(y, k, n) = map(int, input().split())
x0 = (y // k + 1) * k - y
curr = y
diff = 0
ans = []
while True:
	curr = y + x0 + diff
	if curr <= n:
		ans.append(x0 + diff)
		diff += k
	else:
		break
if not len(ans):
	print(-1)
else:
	for x in sorted(ans):
		print(x, end=' ')


(y, k, n) = map(int, input().split())
if n < k or y > n or y // k == n // k:
	print(-1)
else:
	for x in range(k * (1 + y // k), n + 1, k):
		print(x - y, end=' ')


(y, k, n) = map(int, input().split(' '))
r_x = n - y
j = k - y % k
if j <= r_x and j >= 1:
	for i in range(j, r_x + 1, k):
		print(i, end=' ')
else:
	print(-1)


import math
inputLine = input().split()
y = int(inputLine[0])
k = int(inputLine[1])
n = int(inputLine[2])
sumOfPotatoes = n - n % k
x = sumOfPotatoes - y
if x < 1:
	print(-1)
else:
	outputArray = []
	while x >= 1:
		outputArray.append(x)
		x -= k
	for x in reversed(outputArray):
		print(x, end=' ')


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
(y, k, n) = map(int, input().split())
ans = []
start = k - y % k
if start == 0:
	start += k
while y + start <= n:
	ans.append(start)
	start += k
if len(ans) == 0:
	print(-1)
else:
	for pot in ans:
		print(pot, end=' ')
	print('')


temp = list(map(int, input().split()))
y = temp[0]
k = temp[1]
n = temp[2]
possible = []
c = 1
x = None
while True:
	x = c * k - y
	if x + y > n:
		break
	if x > 0:
		possible.append(x)
	c += 1
if len(possible) == 0:
	print('-1')
else:
	for x in possible:
		print(x, end=' ')


(y, k, n) = list(map(int, input().split()))
c = 0
a = []
if n - y <= 0:
	print(-1)
else:
	for i in range(k - y % k, n - y + 1):
		if (i + y) % k == 0:
			v = i
			c += 1
			break
	if c == 0:
		print(-1)
	else:
		for l in range(v, n - y + 1, k):
			a.append(l)
		for u in a:
			print(u, end=' ')