We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:

  The array consists of $n$ distinct positive (greater than $0$) integers.  The array contains two elements $x$ and $y$ (these elements are known for you) such that $x < y$.  If you sort the array in increasing order (such that $a_1 < a_2 < \ldots < a_n$), differences between all adjacent (consecutive) elements are equal (i.e. $a_2 - a_1 = a_3 - a_2 = \ldots = a_n - a_{n-1})$. 

It can be proven that such an array always exists under the constraints given below.

Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize $\max(a_1, a_2, \dots, a_n)$.

You have to answer $t$ independent test cases.


-----Input-----

The first line of the input contains one integer $t$ ($1 \le t \le 100$) — the number of test cases. Then $t$ test cases follow.

The only line of the test case contains three integers $n$, $x$ and $y$ ($2 \le n \le 50$; $1 \le x < y \le 50$) — the length of the array and two elements that are present in the array, respectively.


-----Output-----

For each test case, print the answer: $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^9$), where $a_i$ is the $i$-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).

It can be proven that such an array always exists under the given constraints.


-----Example-----
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22

Output
1 49 
20 40 30 50 10
26 32 20 38 44 50 
8 23 18 13 3 
1 10 13 4 19 22 25 16 7

Difficulty: EASY
Tags: Number theory

Mathematics

Complete search
Skill types: Complete search

Starter code:

Solutions:
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 RL():
	return map(int, sys.stdin.readline().rstrip().split())

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

def N():
	return int(input())

def print_list(l):
	print(' '.join(map(str, l)))
from math import ceil, floor, sqrt, pow
n = int(input())
for _ in range(n):
	(n, x, y) = map(int, sys.stdin.readline().rstrip().split())
	for t in range(n - 1, 0, -1):
		if (y - x) % t == 0:
			d = (y - x) // t
			kk = ceil(y / d)
			r = max(0, n - kk)
			mm = y + r * d
			print_list([mm - i * d for i in range(n)])
			break


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	a = [x, y]
	if n > 2:
		n -= 2
		d = y - x
		i = 1
		dif = i
		l = []
		for i in range(1, d + 1):
			if d % i == 0:
				l.append(i)
		for i in l:
			if n >= d // i - 1:
				dif = i
				break
		start = x + dif
		while start < y and n > 0:
			a.append(start)
			n -= 1
			start += dif
		x -= dif
		while x > 0 and n > 0:
			a.append(x)
			x -= dif
			n -= 1
		y += dif
		while n > 0:
			n -= 1
			a.append(y)
			y += dif
	print(*a)


for s in [*open(0)][1:]:
	(n, x, y) = map(int, s.split())
	diff = y - x
	for d in range(1, diff + 1):
		if diff % d:
			continue
		if diff // d + 1 > n:
			continue
		k = min((y - 1) // d, n - 1)
		a0 = y - k * d
		for i in range(n):
			print(a0 + i * d, end=' ')
		print('')
		break


import sys
import math
import collections
import bisect

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

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

def get_string():
	return sys.stdin.readline().strip()
for t in range(int(input())):
	(n, a, b) = get_ints()
	diff_gb = b - a
	maxim = 10 ** 10
	sol = []
	for i in range(1, diff_gb + 1):
		if diff_gb % i != 0:
			continue
		(x, y) = (a, b)
		ans = [x, y]
		diff = i
		while y > x + diff:
			if len(ans) == n:
				break
			y -= diff
			ans.append(y)
			if len(ans) == n:
				break
		while x > i:
			if len(ans) == n:
				break
			x -= i
			ans.append(x)
			if len(ans) == n:
				break
		y = b + diff
		while len(ans) < n:
			ans.append(y)
			y += diff
		common_diff = set()
		ans.sort()
		for j in range(1, n):
			common_diff.add(ans[j] - ans[j - 1])
		if max(ans) < maxim and len(common_diff) == 1:
			maxim = max(ans)
			sol = ans
	print(*sol)


def read_int():
	return int(input())

def read_ints():
	return map(int, input().split(' '))
t = read_int()
for case_num in range(t):
	(n, x, y) = read_ints()
	d = y - x
	for i in range(n - 1, 0, -1):
		if d % i == 0:
			d //= i
			l = min(n - (i + 1), (x - 1) // d)
			ans = [x - l * d + i * d for i in range(n)]
			print(' '.join(map(str, ans)))
			break


import sys
for _ in range(int(input())):
	(n, x, y) = [int(i) for i in input().split()]
	diff = y - x
	p = []
	check = -1
	for i in range(1, diff + 1):
		if diff % i == 0 and diff // i <= n - 1:
			check = i
			break
	a = [x]
	for i in range(n - 1):
		if a[-1] + check <= y:
			a.append(a[-1] + check)
		else:
			break
	temp = []
	while len(a) + len(temp) < n:
		if len(temp) == 0 and a[0] - check < 1:
			a.append(a[-1] + check)
		elif len(temp) != 0 and temp[-1] - check < 1:
			a.append(a[-1] + check)
		elif len(temp) == 0 and a[0] - check >= 1:
			temp.append(a[0] - check)
		elif len(temp) != 0 and temp[-1] - check >= 1:
			temp.append(temp[-1] - check)
	temp.reverse()
	ans = temp[:]
	ans.extend(a)
	print(*ans)


def divisors(a, b):
	result = []
	x = b - a
	for i in range(1, x + 1):
		if x % i == 0:
			result.append(i)
	return result

def solution():
	x = int(input())
	for _ in range(x):
		(n, x, y) = input().split()
		my_divisors = divisors(int(x), int(y))
		gap = int(y) - int(x)
		current_max = int(y) - int(x)
		if int(y) - int(x) - 1 == int(n) - 2:
			current_max = 1
		else:
			for i in range(len(my_divisors)):
				if my_divisors[i] * int(n) - 2 >= gap >= gap - my_divisors[i]:
					current_max = my_divisors[i]
					break
		count = int(n) - 1
		current = int(x)
		print(str(current), end='')
		current += current_max
		while current < int(y) and count > 1:
			print(' ' + str(current), end='')
			current += current_max
			count -= 1
		print(' ' + str(int(y)), end='')
		count -= 1
		current = int(x) - current_max
		while current >= 1 and count > 0:
			print(' ' + str(current), end='')
			current -= current_max
			count -= 1
		current = int(y) + current_max
		while count > 0:
			print(' ' + str(current), end='')
			current += current_max
			count -= 1
		print()
solution()


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
from collections import deque, defaultdict, OrderedDict
from fractions import Fraction
from decimal import Decimal

def main():
	starttime = datetime.datetime.now()
	if os.path.exists('input.txt'):
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	for _ in range(ri()):
		(n, x, y) = ria()
		c = y - x
		f = x - (x - 1)
		g = y - (x - 1)
		for i in range(1, c + 1):
			if c % i == 0:
				s = 1
				a = [s]
				t = 0
				for k in range(1, 51):
					s += i
					a.append(s)
				h = a.index(g)
				if h + 1 <= n:
					z = i
					break
		ans = [x]
		e = x
		s = x
		for i in range(n - 1):
			s += z
			ans.append(s)
		for j in range(n - 1, -1, -1):
			if ans[j] == y or e - z < 1:
				break
			else:
				e -= z
				ans[j] = e
		print(*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()


import math
t = int(input())
for i in range(t):
	(n, x, y) = [int(i) for i in input().split()]
	posinc = list(filter(lambda a: (y - x) % a == 0, range(1, y - x + 1)))
	inc = list(filter(lambda a: a >= math.ceil((y - x) / (n - 1)), posinc))[0]
	xs = x % inc
	if xs == 0:
		xs = inc
	sol = [j for j in range(xs, y + 1, inc)]
	if len(sol) >= n:
		print(' '.join((str(aa) for aa in sol[len(sol) - n:])))
		continue
	diff = n - len(sol)
	print(' '.join((str(aa) for aa in sol + [j for j in range(y + inc, y + (inc * diff + 1), inc)])))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	c = n - 1
	d = y - x
	while c >= 1:
		if d % c == 0:
			break
		c = c - 1
	a = d // c
	while c < n - 1:
		if x > a:
			x = x - a
			c = c + 1
		else:
			break
	print(x, end=' ')
	for i in range(n - 1):
		x = x + a
		print(x, end=' ')
	print('\n')


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
		continue
	for j in range(1, 50):
		if (y - x) % j == 0:
			if (y - x) // j + 1 <= n:
				b = (y - x) // j
				l = [max(x % j, x - (n - 1 - b) * j)]
				if l[0] == 0:
					l[0] = j
				for k in range(1, n):
					l.append(l[k - 1] + j)
				break
	print(*l)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = 1000000000.0
	for i in range(n - 1, 0, -1):
		if (y - x) % i == 0:
			diff = min((y - x) // i, diff)
			break
	arr = [*range(x, y + 1, diff)]
	arr = arr[::-1]
	x = arr[-1]
	x -= diff
	while x >= 1 and len(arr) < n:
		arr.append(x)
		x -= diff
	arr = arr[::-1]
	x = arr[-1]
	x += diff
	while len(arr) < n:
		arr.append(x)
		x += diff
	print(*arr)


import sys
for _ in range(int(input())):
	(n, x, y) = map(int, sys.stdin.readline().split())
	k = y - x
	k_list = []
	for i in range(1, int(k ** 0.5) + 1):
		if k % i == 0:
			k_list.append(i)
			k_list.append(k // i)
	k_list.sort()
	maxi = 0
	for i in k_list:
		if i <= n - 1:
			maxi = i
		else:
			break
	inside = maxi - 1
	multiplier = k // maxi
	ans_arr = []
	if y - multiplier * (n - 1) >= 1:
		ans_arr = list(range(y - multiplier * (n - 1), y + multiplier, multiplier))
	else:
		if y % multiplier == 0:
			k = multiplier
		else:
			k = y % multiplier
		ans_arr = list(range(k, k + multiplier * n, multiplier))
	print(' '.join(map(str, ans_arr)))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split(' '))
	a = y - x
	if a <= n - 1:
		d = 1
	else:
		for i in range(2, a + 1):
			if a // i * i == a and a // i <= n - 1:
				d = i
				break
	p = 0
	while x + p * d <= y:
		num = x + p * d
		print(num, end=' ')
		p = p + 1
	c = 1
	while n > p:
		if x - c * d > 0:
			num = x - c * d
			print(num, end=' ')
			p = p + 1
			c = c + 1
		else:
			break
	e = 1
	if n > p:
		while p != n:
			num = y + e * d
			print(num, end=' ')
			e = e + 1
			p = p + 1
	print('')


for i in range(int(input())):
	(n, x, y) = map(int, input().split(' '))
	d = 1
	while (n - 1) * d < y - x or (y - x) % d:
		d += 1
	start = max((y - 1) % d + 1, y - (n - 1) * d)
	print(*(start + d * i for i in range(n)))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	z = y - x
	for d in range(n - 1, 0, -1):
		if z % d < 1:
			break
	e = z // d
	s = max(y - (n - 1) * e, (y - 1) % e + 1)
	print(' '.join(map(str, range(s, s + e * n, e))))


for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	i = (y - x) // n + 1
	t = y
	while (y - x) % i:
		i += 1
	while y > 0 and n > 0:
		print(y, end=' ')
		y -= i
		n -= 1
	while n:
		t += i
		print(t, end=' ')
		n -= 1
	print()


import sys
import math
fast_reader = sys.stdin.readline
fast_writer = sys.stdout.write

def input():
	return fast_reader().strip()
for T in range(int(input())):
	(n, x, y) = map(int, input().split())
	bw = 0
	d = y - x
	for i in range(n - 1, 1, -1):
		if (y - x) / i == float((y - x) // i):
			bw = i - 1
			d = (y - x) // i
			break
	left = n - 2
	left -= bw
	a = x
	b = y
	temp = x // d
	if temp <= left:
		if x % d == 0:
			if temp != 0:
				temp -= 1
		a = x - temp * d
		left -= temp
		b = y + left * d
	else:
		a = x - left * d
		b = y
	ans = []
	for i in range(a, b + 1, d):
		ans.append(i)
	for i in ans:
		print(i, end=' ')
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	b = [0] * n
	if n == 2:
		b[0] = x
		b[1] = y
		for i in b:
			print(i, end=' ')
		print()
	else:
		b[n - 1] = 10 ** 9
		for i in range(n):
			for j in range(i + 1, n):
				a = [0] * n
				a[i] = x
				a[j] = y
				diff = y - x
				d = j - i
				if diff % d == 0:
					diff = diff // d
					for k in range(i - 1, -1, -1):
						a[k] = a[k + 1] - diff
					for k in range(i + 1, n):
						a[k] = a[k - 1] + diff
					if a[0] > 0 and a[n - 1] < b[n - 1]:
						b = a
		for i in b:
			print(i, end=' ')
		print()


t = int(input())
for i in range(t):
	(n, x, y) = [int(j) for j in input().split(' ')]
	k = n - 1
	diff = y - x
	while k >= 1 and diff % k != 0:
		k = k - 1
	d = diff / k
	p = x // d
	number_of_terms_greater_than_zero = p + 1 + (y - x) // d
	if number_of_terms_greater_than_zero >= n:
		ans_in_list = [int(y - r * d) for r in range(n)]
	else:
		t = n - number_of_terms_greater_than_zero
		z = y + t * d
		ans_in_list = [int(z - r * d) for r in range(n)]
	i = 0
	while i < n and ans_in_list[i] != 0:
		i += 1
	if i != n:
		ans_in_list = ans_in_list[:i] + ans_in_list[i + 1:] + [int(ans_in_list[0] + d)]
	ans = ''
	for i in ans_in_list:
		ans = ans + str(i) + str(' ')
	print(ans[:-1])


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, x, y) = [int(j) for j in input().split()]
	ans = []
	mini = min(x, y)
	y = max(x, y)
	x = mini
	diff = []
	arr = []
	for i in range(1, y - x + 1):
		if (y - x) % i == 0 and (y - x) // i <= n - 1:
			diff.append(i)
	for i in range(len(diff)):
		temp = []
		temp.append(x)
		temp.append(y)
		count = 0
		t = 0
		while count < n - 2:
			t += 1
			if x + t * diff[i] >= y:
				break
			count += 1
			temp.append(x + t * diff[i])
		t = 0
		while count < n - 2:
			t += 1
			if x - t * diff[i] <= 0:
				break
			count += 1
			temp.append(x - t * diff[i])
		t = 0
		while count < n - 2:
			count += 1
			t += 1
			temp.append(y + t * diff[i])
		arr.append(temp)
	ans = arr[0]
	print(*ans)


from os import path
import sys
from heapq import heappush, heappop
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().rstrip()

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

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def bo(i):
	return ord(i) - ord('a')
file = 1

def solve():
	for _ in range(ii()):
		(n, x, y) = mi()
		if n == 2:
			print(x, y)
			continue
		diff = y - x
		minv = inf
		mindiff = 1
		for i in range(1, diff + 1):
			if diff % i:
				continue
			n1 = diff // i + 1
			if n1 > n:
				continue
			n1 += (x - 1) // i
			val = n
			if n1 < n:
				val = y + (n - n1) * i
			if val < minv:
				minv = val
				mindiff = i
		ans = [x, y]
		for i in range(x + mindiff, y, mindiff):
			ans.append(i)
		x1 = x - mindiff
		while len(ans) < n and x1 > 0:
			ans.append(x1)
			x1 -= mindiff
		x1 = y + mindiff
		while len(ans) < n:
			ans.append(x1)
			x1 += mindiff
		print(*ans)
if file:
	if path.exists('input.txt'):
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	else:
		input = sys.stdin.readline
solve()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	big_diff = y - x
	y1 = y
	common_diff = 1
	for i in range(n - 1, 0, -1):
		if big_diff % i == 0:
			common_diff = big_diff // i
			break
	print(y1, end=' ')
	for i in range(n - 1):
		if y1 - common_diff > 0:
			print(y1 - common_diff, end=' ')
			y1 -= common_diff
		else:
			print(y + common_diff, end=' ')
			y += common_diff
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	print(x, y, end=' ')
	div = n - 1
	(unsolved, needed, xtra_needed) = (True, 0, 0)
	diff = y - x
	got = 0
	while unsolved:
		if diff % div != 0:
			div -= 1
		else:
			got = int(diff / div)
			needed = div - 1
			xtra_needed = n - div - 1
			unsolved = False
	(another, other, num) = (x, y, 0)
	while another < y and needed > 0:
		another += got
		print(another, end=' ')
		needed -= 1
	while x - got > 0 and xtra_needed > 0:
		x = x - got
		xtra_needed -= 1
		print(x, end=' ')
	while xtra_needed > 0:
		y += got
		xtra_needed -= 1
		print(y, end=' ')
	print()


import sys

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
from collections import defaultdict
for _ in range(ri()):
	(n, x, y) = ria()
	a = y - x
	for i in range(1, a + 1):
		if a % i == 0 and a // i <= n - 1:
			break
	if n == 2:
		print(x, y)
	else:
		q = a // i
		l = []
		j = 0
		z = x % i
		if z == 0:
			z = i
		while z <= y:
			l.append(z)
			z += i
		if len(l) < n:
			for __ in range(n - len(l)):
				l.append(z)
				z += i
		l = l[::-1]
		print(*l[:n])


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		dif = y - x
		for i in range(n - 1, -1, -1):
			if dif % i == 0:
				a = dif // i
				break
		print(y, end=' ')
		c = 1
		for i in range(1, n):
			if y - i * a > 0:
				print(y - i * a, end=' ')
				c = c + 1
			else:
				break
		if c != n:
			for i in range(1, n - c + 1):
				print(y + i * a, end=' ')
		print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = n - 1
	while (x - y) % d != 0:
		d -= 1
	k = n
	cc = 1
	d = (y - x) // d
	t = 1
	while k > 0:
		j = y - (n - k * cc) * d
		if j >= 1 and cc == 1:
			print(j, end=' ')
		else:
			cc = -1
			j = y + t * d
			print(j, end=' ')
			t += 1
		k -= 1
	print()


for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	o = y - x
	arr = [0] * n
	m = 10 ** 11
	for i in range(1, x + 1):
		for d in range(1, 50):
			if not (o % d != 0 or (y - i) % d != 0 or (y - i) // d >= n):
				if m > i + d * (n - 1):
					m = i + d * (n - 1)
					p = i
					q = d
	fa = [0] * n
	for i in range(n):
		fa[i] = p + i * q
	print(*fa)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = []
	d = y - x
	for i in range(1, d + 1):
		if d % i != 0:
			continue
		res = []
		f = False
		temp = y
		tmp = n
		while temp >= 1 and tmp > 0:
			res.append(temp)
			if temp == x:
				f = True
			tmp -= 1
			temp -= i
		temp = y
		while tmp > 0:
			temp += i
			res.append(temp)
			tmp -= 1
		res.sort()
		if tmp == 0 and f == True:
			if len(ans) == 0 or ans[-1] > res[-1]:
				ans = res
	print(' '.join(map(str, ans)))


import math

class Read:

	@staticmethod
	def string():
		return input()

	@staticmethod
	def int():
		return int(input())

	@staticmethod
	def list(sep=' '):
		return input().split(sep)

	@staticmethod
	def list_int(sep=' '):
		return list(map(int, input().split(sep)))

def solve():
	(n, x, y) = Read.list_int()
	v = y - x
	q = 0
	for i in range(n - 1, 1, -1):
		if v % i == 0:
			q = i
			break
	res = [str(x), str(y)]
	if q:
		t = int(v / q)
		for i in range(int(q - 1)):
			res.append(str(x + t * (i + 1)))
	else:
		t = y - x
	l = x - t
	while len(res) != n and l > 0:
		res.append(str(l))
		l = l - t
	l = y + t
	while len(res) != n:
		res.append(str(l))
		l = l + t
	print(' '.join(res))
query_count = Read.int()
while query_count:
	query_count -= 1
	solve()


import sys
from math import sqrt
from collections import defaultdict
inpt = sys.stdin.readline

def inp():
	return int(inpt())

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

def instr():
	s = inpt()
	return list(s[:len(s) - 1])

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

class Graph:

	def __init__(self, n):
		self.n = n
		self.graph = defaultdict(list)
		self.marked = defaultdict(int)

	def addEdge(self, u, v):
		self.graph[u].append(v)
		self.graph[v].append(u)

	def dfs(self, u):
		self.marked[u] = 1
		for i in self.graph[u]:
			if self.marked[i] == 0:
				self.dfs(i)

def main():
	t = inp()
	for l in range(t):
		(n, x, y) = invr()
		step = (y - x) // n
		ans = []
		ans.append(x)
		ans.append(y)
		for i in range(step + 1, y - x + 1):
			if (y - x) % i == 0:
				minstep = i
				break
		numins = (y - x) // minstep - 1
		temp = x
		for i in range(numins):
			ans.append(temp + minstep)
			temp += minstep
		rem = n - numins
		while x - minstep > 0 and rem > 0:
			rem -= 1
			x -= minstep
			ans.append(x)
		while rem > 0:
			rem -= 1
			y += minstep
			ans.append(y)
		for i in range(n):
			print(ans[i], end=' ')
		print()
main()


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	maxi = 10 ** 18
	final = []
	for a in range(1, 51):
		for d in range(1, 51):
			flag = 0
			ans = []
			for i in range(1, n + 1):
				ans.append(a + (i - 1) * d)
				if ans[-1] == x or ans[-1] == y:
					flag += 1
			if flag == 2:
				if ans[-1] < maxi:
					maxi = min(ans[-1], maxi)
					final = ans
	print(*final)


from math import inf
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		t = y - x
		a = [inf] * n
		for i in range(1, t + 1):
			if t % i == 0:
				arr = []
				if t // i - 1 <= n - 2:
					arr += [x]
					f = 2
					s = x + i
					while s < y:
						arr += [s]
						s += i
						f += 1
					arr += [s]
					s = x - i
					while s > 0 and f < n:
						arr = [s] + arr
						s -= i
						f += 1
					s = y + i
					while f < n:
						arr += [s]
						s += i
						f += 1
					if f == n and arr[-1] < a[-1]:
						a = arr[:]
		print(*a)


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split(' '))
	for j in range(1, y - x + 1):
		if (y - x) % j != 0:
			continue
		if (y - x) // j + 1 <= n:
			a = list()
			if y % j == 0:
				a.append(max(y - j * (n - 1), y % j + j))
			else:
				a.append(max(y - j * (n - 1), y % j))
			print(a[0], sep='', end=' ')
			for k in range(1, n - 1):
				a.append(a[-1] + j)
				print(a[k], sep='', end=' ')
			print(a[-1] + j)
			break


def main():
	t = int(input())
	while t:
		(n, x, y) = map(int, input().split())
		ans = []
		for a in range(1, 51):
			for d in range(1, 51):
				ap = [term for term in range(a, a + (n - 1) * d + 1, d)]
				if x in ap and y in ap:
					ans = ap if len(ans) == 0 or ap[-1] < ans[-1] else ans
		for i in ans:
			print(i, end=' ')
		print()
		t -= 1
main()


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	if (y - x) % (n - 1) == 0:
		d = (y - x) // (n - 1)
		a = x
		for j in range(n):
			print(a, end=' ')
			a += d
	else:
		a = n - 1
		while (y - x) % a != 0:
			a -= 1
		d = (y - x) // a
		first = y - (n - 1) * d
		if first <= 0:
			while first <= 0:
				first += d
		for j in range(n):
			print(first, end=' ')
			first += d
	print()


def go():
	(n, x, y) = map(int, input().split())
	tmp = y - x
	fg = 0
	for i in range(n - 1, 0, -1):
		if tmp % i == 0:
			fg = tmp // i
			break
	mid = tmp // fg + 1
	num = 0
	tmp = x - fg
	while tmp > 0 and num + mid < n:
		num += 1
		tmp -= fg
	if num + mid == n:
		ans = []
		for i in range(n):
			ans.append(y)
			y -= fg
		print(' '.join((str(i) for i in ans)))
	else:
		tmp += fg
		ans = []
		for i in range(n):
			ans.append(tmp)
			tmp += fg
		print(' '.join((str(i) for i in ans)))
fg = 1
if fg:
	tt = int(input())
	for i in range(tt):
		go()
else:
	go()


for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	minMax = 100000
	minD = 0
	minStart = 0
	for d in range(1, y - x + 1):
		if (y - x) % d != 0 or d * (n - 1) < y - x:
			continue
		minElem = x % d
		if minElem == 0:
			minElem = d
		maxElem = minElem + d * (n - 1)
		if maxElem < y:
			maxElem = y
			minElem = maxElem - d * (n - 1)
		if maxElem < minMax:
			minMax = maxElem
			minStart = minElem
			minD = d
	ans = []
	elem = minStart
	for i in range(n):
		ans.append(str(elem))
		elem += minD
	print(' '.join(ans))


from math import *
for u in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = [10 ** 9] * n
	for i in range(1, 51):
		for j in range(1, 51):
			l = []
			for k in range(n):
				l.append(i + j * k)
			if x in l and y in l:
				if max(l) < max(d):
					d = l
	print(*d)


import os
import sys
from io import BytesIO, IOBase

def solution(n, x, y):
	res_min = float('inf')
	for i in range(1, x + 1):
		start = i
		for d in range(1, y - x + 1):
			if start + (n - 1) * d < y:
				continue
			ap = range(start, start + (n - 1) * d + 1, d)
			if x in ap and y in ap:
				cur = start + (n - 1) * d
				if cur < res_min:
					res_min = cur
					res_i = start
					res_d = d
	write(*range(res_i, res_min + 1, res_d))

def main():
	for _ in range(r_int()):
		(n, x, y) = r_array()
		solution(n, x, y)
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))

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

def write(*args, end='\n'):
	for x in args[:-1]:
		sys.stdout.write(str(x) + ' ')
	sys.stdout.write(str(args[-1]))
	sys.stdout.write(end)

def r_array():
	return [int(x) for x in input().split()]

def r_int():
	return int(input())
main()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(f'{x} {y}')
	else:
		for d in range(1, y - x + 1):
			if (y - x) % d != 0:
				continue
			elem = y - d * (n - 1)
			if elem > x:
				continue
			result = [y - d * i for i in range(0, n) if y - d * i > 0]
			remainder = n - len(result)
			result += [y + d * i for i in range(1, remainder + 1)]
			print(' '.join([str(x) for x in result]))
			break


test = int(input())
for _ in range(test):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(min(x, y), end=' ')
		print(max(x, y))
	else:
		for i in range(1, 50):
			for j in range(1, 50):
				d = i
				a = j
				ap = []
				inc = 0
				flag = False
				for k in range(n):
					ap.append(a + k * d)
					if a + k * d == x or a + k * d == y:
						inc += 1
				if inc == 2:
					flag = True
					for num in ap:
						print(num, end=' ')
					print()
					break
			if flag:
				break


import sys
input = sys.stdin.readline

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

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

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

class Solution:

	def main(self, n, x, y):
		if n == 2:
			return [x, y]
		(p, diff, num) = (y - x, -1, 0)
		for i in range(n - 1, 0, -1):
			if p % i == 0:
				diff = p // i
				num = i - 1
				break
		n = n - 2 - num
		res = list(range(x, y + 1, diff))
		i = x
		while n > 0 and i > 0:
			i -= diff
			if i > 0:
				res.append(i)
				n -= 1
		i = y
		while n > 0:
			i += diff
			res.append(i)
			n -= 1
		return res
t = inp()
solution = Solution()
for _ in range(t):
	(n, x, y) = inlt()
	res = solution.main(n, x, y)
	print(' '.join(map(str, res)))


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	d = 0
	for i in range(1, y - x + 1):
		if (y - x) % i == 0:
			if (y - x) // i + 1 <= n:
				d = i
				break
	print(y, end=' ')
	n -= 1
	for i in range(x, y, d):
		print(i, end=' ')
		n -= 1
	prevy = y
	prevx = x
	while n > 0:
		if prevx - d > 0:
			n -= 1
			print(prevx - d, end=' ')
			prevx -= d
		elif prevy + d > 0:
			n -= 1
			print(prevy + d, end=' ')
			prevy += d
	print()


t = int(input())
while t > 0:
	sdf = input().split()
	n = int(sdf[0])
	x = int(sdf[1])
	y = int(sdf[2])
	if n == 2:
		print(x, y)
		t -= 1
		continue
	gap = y - x
	i = 1
	while i <= gap:
		if gap % i == 0 and gap // i + 1 <= n:
			div = gap // i + 1
			rem = n - div
			hm = (x - 1) // i
			start = x - i * hm
			if div + hm >= n:
				start = x - i * rem
			k = 0
			while k < n:
				print(start + i * k, end=' ')
				k += 1
			break
		if i == gap // 2:
			i = gap - 1
		i += 1
	print()
	t -= 1


import math

def factor(n):
	a = []
	for i in range(2, n // 2 + 1):
		if n % i == 0:
			a.append(i)
	return a
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	z = math.ceil((y - x) / (n - 1))
	for i in range(z, 50):
		if diff % i == 0:
			d = i
			break
	s = y
	ans = []
	while n > 0 and s > 0:
		ans.append(s)
		s -= d
		n -= 1
	s = y + d
	while n > 0:
		ans.append(s)
		s += d
		n -= 1
	print(*ans)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = y - x
	for i in range(min(n - 1, d), 0, -1):
		if not d % i:
			d = d // i
			break
	count = 0
	while n > 0 and y - count * d > 0:
		print(y - count * d, end=' ')
		count += 1
		n -= 1
	count = 1
	while n > 0:
		print(y + count * d, end=' ')
		count += 1
		n -= 1
	print()


for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	for i in range(1, y - x + 1):
		a = (y - x) / i
		if a == int(a) and a < n:
			ans = list(range(x, y + i, i))
			k = x - i
			while len(ans) < n and k > 0:
				ans.append(k)
				k -= i
			k = y + i
			while len(ans) < n:
				ans.append(k)
				k += i
			print(*ans)
			break


import math
T = int(input())
for t in range(T):
	(n, x, y) = [int(i) for i in input().split(' ')]
	intvl = 1
	diff = y - x
	while diff % intvl != 0 or diff / intvl > n - 1:
		intvl += 1
	arr = []
	cur = y
	while len(arr) < n and cur > 0:
		arr.append(cur)
		cur -= intvl
	if len(arr) < n:
		cur = y + intvl
		while len(arr) < n:
			arr.append(cur)
			cur += intvl
	print(*arr)


from sys import stdin, gettrace
if gettrace():
	inputi = input
else:

	def input():
		return next(stdin)[:-1]

	def inputi():
		return stdin.buffer.readline()

def solve():
	(n, x, y) = map(int, inputi().split())
	step = 1
	while (y - x) % step != 0 or (y - x) // step > n - 1:
		step += 1
	start = max(x % step, y - step * (n - 1))
	if start == 0:
		start = step
	print(' '.join(map(str, range(start, step * n + start, step))))

def main():
	t = int(inputi())
	for _ in range(t):
		solve()
main()


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	c = 0
	for i in range(n - 1, 0, -1):
		if (y - x) % i == 0:
			c = (y - x) // i
			break
	d = []
	x = y
	while n:
		if y > 0:
			d.append(y)
			y -= c
		else:
			x += c
			d.append(x)
		n -= 1
	print(*d)


for _ in range(int(input())):
	(n1, x, y) = map(int, input().split())
	run = False
	for d in range(y - x + 2):
		for n_x in range(n1 + 1, -1, -1):
			a1 = x - d * (n_x - 1)
			if a1 > 0:
				for n_y in range(n_x, n1 + 1):
					if y == a1 + d * (n_y - 1):
						a = [a1 + d * (n2 - 1) for n2 in range(n1)]
						if min(a) > 0 and y in a:
							run = True
							break
			if run:
				break
		if run:
			break
	print(*a)


def getArr(n, x, y):
	diff = y - x
	steps = n - 1
	while steps >= 1:
		div = diff / steps
		if div == diff // steps:
			break
		steps -= 1
	left = n - 1 - steps
	while left > 0:
		if x - div > 0:
			x -= div
		else:
			y += div
		left -= 1
	num = x
	while num <= y:
		print(int(num), end=' ')
		num += div
	print('')
T = int(input())
for t in range(T):
	(n, x, y) = [int(i) for i in input().split(' ')]
	getArr(n, x, y)


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter
from itertools import combinations as comb
from itertools import permutations as permutate
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
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))
from types import GeneratorType

def iterative(f, stack=[]):

	def wrapped_func(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		to = f(*args, **kwargs)
		while True:
			if type(to) is GeneratorType:
				stack.append(to)
				to = next(to)
				continue
			stack.pop()
			if not stack:
				break
			to = stack[-1].send(to)
		return to
	return wrapped_func
mod = 1000000007

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 zerolist(n):
	return [0] * n

def nextline():
	out('\n')

def testcase(t):
	for pp in range(t):
		solve(pp)

def printlist(a):
	for p in range(0, len(a)):
		out(str(a[p]) + ' ')

def google(p):
	print('Case #' + str(p) + ': ', end='')

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

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def solve(case):
	(n, x, y) = sep()
	temp = y - x
	div = []
	for i in range(1, floor(temp ** 0.5) + 1):
		if temp % i == 0:
			div.append(i)
			if i != temp // i:
				div.append(temp // i)
	d = temp
	div = sorted(div)
	for i in range(len(div)):
		chck = temp // div[i]
		chck += 1
		if chck <= n:
			d = div[i]
			break
	ans = []
	for i in range(y, 0, -d):
		ans.append(i)
		if len(ans) == n:
			break
	curr = y
	while len(ans) != n:
		ans.append(curr + d)
		curr += d
	print(' '.join((str(ans[i]) for i in range(len(ans)))))
testcase(int(inp()))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	for d in range(1, 50):
		if (y - x) % d != 0:
			continue
		if (y - x) / d >= n:
			continue
		lst = []
		lst.extend(range(y, 0, -d))
		lst = lst[:n]
		a = lst[-1]
		lst.extend(range(a, a + d * n, d))
		lst = list(set(lst))[:n]
		print(' '.join(map(str, lst)))
		break


import sys
import math
from collections import defaultdict, Counter
input = sys.stdin.readline
t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	ans = [10 ** 9, y - x, x]
	for j in range(1, 50):
		if (y - x) % j == 0 and y <= x + (n - 1) * j:
			gone = (y - x) // j + 1
			left = min(n - gone, (x - 1) // j)
			gone += left
			if gone < n:
				right = y + j * (n - gone)
			else:
				right = y
				ans = [right, j, left]
				break
			if right <= ans[0]:
				ans = [right, j, left]
	start = x - ans[1] * ans[2]
	for j in range(n):
		print(start, end=' ')
		start += ans[1]
	print()


import sys
import math
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	(x, y) = (min(x, y), max(x, y))
	allans = []
	for i in range(n):
		for j in range(i + 1, n):
			if (y - x) % (j - i) == 0:
				diff = (y - x) // (j - i)
				arr = [0] * n
				arr[i] = x
				flag = 0
				for k in range(i - 1, -1, -1):
					arr[k] = arr[k + 1] - diff
					if arr[k] <= 0:
						flag = 1
				for k in range(i + 1, n):
					arr[k] = arr[k - 1] + diff
					if arr[k] <= 0:
						flag = 1
				if flag == 0:
					allans.append([max(arr), arr[:]])
	allans.sort()
	print(*allans[0][1])


T = int(input())
for _ in range(T):
	(n, a, b) = map(int, input().split())
	counter = 1
	while True:
		ans = [b]
		small = True
		while len(ans) != n:
			if small:
				diff = ans[0] - counter
				if diff > 0:
					ans.insert(0, diff)
				else:
					small = False
			else:
				diff = ans[-1] + counter
				ans.insert(len(ans), diff)
		if a in ans and b in ans:
			print(*ans)
			break
		if counter == 60:
			break
		counter += 1


t = int(input())
result = []
for _ in range(t):
	c = input().split()
	(n, x, y) = (int(c[0]), int(c[1]), int(c[2]))
	result = []
	if n == 2:
		print(x, y)
	else:
		result = []
		count = n - 1
		while (y - x) % count != 0 and count >= 1:
			count -= 1
		dif = (y - x) // count
		result.append(x)
		[result.append(x + i * dif) for i in range(1, count + 1)]
		temp = x
		while len(result) < n and temp - dif >= 1:
			temp = temp - dif
			result.append(temp)
		temp = y
		while len(result) < n:
			temp = temp + dif
			result.append(temp)
		print(*result)


def solve(n, x, y):
	result = []
	for i in range(n - 1, 0, -1):
		d = (y - x) / i
		rem = (y - x) % i
		if rem == 0:
			d = int(d)
			for num in range(x, y + 1, d):
				n -= 1
				result.append(num)
			for num in range(x - d, 0, -d):
				if n == 0:
					break
				n -= 1
				result.append(num)
			for num in range(n):
				if n == 0:
					break
				y += d
				n -= 1
				result.append(y)
			return result
testCases = input()
for i in range(int(testCases)):
	(n, x, y) = map(int, input().split())
	ans = solve(n, x, y)
	print(' '.join([str(i) for i in ans]))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = n - 2
	while (y - x) % (d + 1):
		d -= 1
	d = (y - x) // (d + 1)
	i = y
	while i > 0 and n > 0:
		print(i, end=' ')
		i -= d
		n -= 1
	while n > 0:
		print(y + n * d, end=' ')
		n -= 1
	print()


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	for d in range(1, y - x + 1):
		if (y - x) % d == 0 and (y - x) // d <= n - 1:
			offset = y % d
			if offset == 0:
				offset = d
			print(' '.join(map(str, (max(y, offset + (n - 1) * d) - d * i for i in range(n)))))
			break


for _ in range(int(input())):
	(a, b, c) = [int(x) for x in input().split()]
	i = a
	while (c - b) % (i - 1) != 0:
		i -= 1
	difference = (c - b) // (i - 1)
	left_term = (b - 1) // difference
	if left_term + i >= a:
		ans = c
	else:
		ans = (a - (left_term + i)) * difference + c
	for i in range(a):
		print(ans, end=' ')
		ans -= difference
	print()


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	for i in range(n - 1, 0, -1):
		diff = abs(x - y)
		if diff % i == 0:
			d = int(diff / i)
			break
	arr = [] * n
	j = x
	while j <= y:
		arr.append(j)
		j += d
		n -= 1
	if n != 0:
		j = x - d
		while j > 0 and n != 0:
			arr.append(j)
			j -= d
			n -= 1
	if n != 0:
		j = y + d
		while n != 0:
			arr.append(j)
			j += d
			n -= 1
	print(*arr, sep=' ')


def solve():
	(n, x, y) = map(int, input().split())
	if x == y:
		for i in range(n):
			print(x, end=' ')
		return
	fa = 10 ** 9
	mx = 10 ** 9
	fcd = 10 ** 9
	for a in range(1, min(x, y) + 1, +1):
		for cd in range(1, abs(x - y) + 1, +1):
			if (x - a) % cd == 0 and (y - a) % cd == 0:
				t = a + (n - 1) * cd
				if t < mx and t >= max(x, y):
					fcd = cd
					fa = a
					mx = t
	for i in range(n):
		print(fa + i * fcd, end=' ')
	print('\n')
t = int(input())
for _ in range(t):
	solve()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = y - x
	factor = 1
	for i in range(2, n):
		if d % i == 0:
			factor = i
	diff = d // factor
	factor -= 1
	n -= factor + 2
	pre = x - min(n, (x - 1) // diff) * diff
	n -= min(n, (x - 1) // diff)
	suff = y + n * diff
	l = []
	for i in range(pre, suff + 1, diff):
		l.append(i)
	print(' '.join(list(map(str, l))))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	mi = 1000000000
	an = []
	for d in range(1, y - x + 1):
		if (y - x) % d == 0:
			for a in range(1, x + 1):
				arr = [a + d * i for i in range(n)]
				if x in arr and y in arr:
					if mi > arr[-1]:
						mi = arr[-1]
						ans = arr
	print(*ans)


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	l = []
	s = n - 2
	m = y - x
	for j in range(s + 1):
		if m % (j + 1) == 0:
			d = m // (j + 1)
	for j in range(x, y + 1, d):
		l.append(j)
	j1 = m // d + 1
	if j1 < n:
		L = x
		while True:
			L = L - d
			if L >= 1 and j1 < n:
				l.append(L)
				j1 += 1
			else:
				break
	if j1 < n:
		R = y
		while True:
			if j1 == n:
				break
			R = R + d
			l.append(R)
			j1 += 1
	for u in l:
		print(u, end=' ')
	print()


rr = lambda : input().strip()
rri = lambda : int(rr())
rrm = lambda : [int(x) for x in rr().split()]
from sys import stdin, stdout, setrecursionlimit
from math import ceil

def sol():
	(n, x, y) = rrm()
	if n == 2:
		print(x, y)
		return
	z = n - 1
	dif = y - x
	res = [0] * n
	l = ceil(dif / z)
	while dif % l != 0:
		l += 1
	i = 0
	tmp = x
	while tmp <= y:
		res[i] = tmp
		i += 1
		tmp += l
		n -= 1
	tmp = x - l
	while n > 0 and tmp > 0:
		res[i] = tmp
		i += 1
		n -= 1
		tmp -= l
	tmp = y + l
	while n > 0:
		res[i] = tmp
		tmp += l
		i += 1
		n -= 1
	print(*res)
	return

def main():
	T = rri()
	for t in range(1, T + 1):
		ans = sol()
main()


t = int(input())
for _ in range(t):
	(nn, x, y) = map(int, input().split())
	if nn == 2:
		print(x, y)
		continue
	n = nn
	diff = y - x
	prime = True
	maxdivisor = 1
	for i in range(min(diff // 2, n), 1, -1):
		if diff % i == 0:
			prime = False
			if i > n - 1:
				continue
			else:
				maxdivisor = i
				break
	if n > diff:
		inc = 1
	elif prime:
		inc = diff
	else:
		inc = diff // maxdivisor
	mid = diff // inc
	n -= mid + 1
	start = x - min(x // inc if x % inc != 0 else x // inc - 1, n) * inc
	ans = [start + inc * i for i in range(nn)]
	print(*ans)


from math import *
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	x = min(x, y)
	y = max(x, y)
	ans = float('inf')
	ft = 0
	cd = 0
	for i in range(1, n):
		for j in range(i + 1, n + 1):
			k = (y - x) / (j - i)
			if ceil(k) == floor(k):
				k = int(k)
				a1 = x - (i - 1) * k
				an = a1 + (n - 1) * k
				if a1 > 0:
					if ans > an:
						ans = an
						ft = a1
						cd = k
	ans = [ft]
	for i in range(n - 1):
		ans.append(ans[-1] + cd)
	print(*ans)


import os
import sys
from io import BytesIO, IOBase
import math
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')
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	d = abs(x - y)
	if d % (n - 1) == 0:
		for i in range(x, y + 1, d // (n - 1)):
			print(i, end=' ')
		print()
	else:
		f = 0
		l = list()
		no = n - 1
		while no:
			no -= 1
			if no != 0 and d % no == 0:
				for i in range(x, y + 1, d // no):
					l.append(i)
				break
		v = n - len(l)
		no = l[1] - l[0]
		s = x - no
		if v > 0:
			while s > 0 and v > 0:
				l.append(s)
				v -= 1
				s -= no
		if v > 0:
			while v > 0:
				l.append(y + no)
				v -= 1
				y += no
		print(*l)


import io
import os
from collections import Counter, defaultdict, deque

def solve(N, X, Y):
	diff = Y - X
	best = (float('inf'),)
	for gap in range(1, N):
		if diff % gap == 0:
			inc = diff // gap
			(i, off) = divmod(X, inc)
			if off == 0:
				off += inc
				i -= 1
			j = i + gap
			while j >= N:
				i -= 1
				j -= 1
				off += inc
			if i < 0:
				continue
			assert 0 <= i < j < N
			assert off > 0
			assert i >= 0
			assert j - i == gap
			assert off + i * inc == X
			assert off + j * inc == Y
			mx = off + (N - 1) * inc
			best = min((mx, inc, off), best)
	(_, inc, off) = best
	ans = [off + inc * i for i in range(N)]
	assert X in ans
	assert Y in ans
	assert all((x > 0 for x in ans))
	assert len(ans) == N
	return ' '.join(map(str, ans))
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
TC = int(input())
for tc in range(1, TC + 1):
	(N, X, Y) = [int(x) for x in input().split()]
	ans = solve(N, X, Y)
	print(ans)


from math import *
from math import factorial as fact, comb as ncr
from bisect import bisect_left as bl
from bisect import bisect_right as br
from collections import Counter as ctr
from collections import deque as dq
from array import array
from re import search
li = lambda : list(map(int, input().split()))
arr = lambda a: array('i', a)
bi = lambda n: bin(n).replace('0b', '')
yn = lambda f: print('NYOE S'[f::2])
sbstr = lambda a, s: search('.*'.join(a), s)

def solve():
	for _ in range(int(input())):
		(n, x, y) = li()
		d = y - x
		gd = 1
		if n < d + 1:
			for i in range(2, d + 1):
				if d % i == 0 and d // i < n:
					gd = i
					break
		m = x
		for i in range(n - 1 - d // gd):
			if m - gd > 0:
				m -= gd
			else:
				break
		for i in range(n):
			print(m + gd * i, end=' ')
		print()
solve()


import sys
for tt in range(0, int(sys.stdin.readline())):
	nxy = sys.stdin.readline().split()
	x = int(nxy[1])
	y = int(nxy[2])
	n = int(nxy[0])
	d = y - x
	minnum = 0
	incr = 0
	for i in range(1, d + 1):
		if d % i == 0 and n >= 1 + (y - x) / i:
			if y - (n - 1) * i <= 0:
				minnum = y - i * int(y / i)
			else:
				minnum = y - (n - 1) * i
			incr = i
			break
	otp = ''
	if minnum == 0:
		minnum = incr
	for i in range(0, n):
		otp += str(minnum + incr * i)
		otp += ' '
	otp += '\n'
	sys.stdout.write(otp)


from math import ceil
for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	z = y - x
	m = n - 1
	d = z / m
	while d != int(d):
		m -= 1
		d = z / m
	d = int(d)
	m += 1
	l = []
	for i in range(x, y + 1, d):
		l.append(i)
		n -= 1
	x -= d
	while n != 0 and x > 0:
		l.append(x)
		x -= d
		n -= 1
	y += d
	while n != 0:
		l.append(y)
		y += d
		n -= 1
	print(*l)


def listres(n, x, y):
	d = y - x
	i = n - 1
	while d % i != 0:
		i -= 1
	et = n - 1 - i
	c = d // i
	k = x
	for j in range(n - 1 - i):
		if k - c > 0:
			k -= c
		else:
			break
	p = ''
	for m in range(n):
		p += str(k) + ' '
		k += c
	return p
t = input()
no = int(t)
s = ''
for i in range(no):
	r2 = input().split(' ')
	s += listres(int(r2[0]), int(r2[1]), int(r2[2])) + '\n'
print(s)


for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	l = []
	mini = 2500000
	for i in range(1, y - x + 1):
		if (y - x) % i == 0:
			l1 = []
			for j in range(n):
				if y - j * i <= 0:
					break
				l1.append(y - j * i)
			if x not in l1:
				continue
			if len(l1) < n:
				a = n - len(l1)
				for j in range(1, a + 1):
					l1.append(y + j * i)
			l1.sort()
			if l1[-1] < mini:
				mini = l1[-1]
				l.append(l1)
	print(' '.join(map(str, l[0])))


t = int(input())
for _ in range(t):
	(n, x, y) = list(map(int, input().split()))
	diff = y - x
	check = lambda no: not diff % no and diff // no - 1 <= n - 2
	factors = list(filter(check, range(1, diff + 1)))
	min_list = None
	max_e = 1000000000
	for f in factors:
		l = list(range(x, y + 1, f))
		cn = len(l)
		ele = x - f
		while cn != n and ele > 0:
			l.append(ele)
			ele -= f
			cn += 1
		ele = y + f
		while cn != n:
			l.append(ele)
			ele += f
			cn += 1
		if max(l) < max_e:
			min_list = l
			max_e = max(l)
	print(' '.join(map(str, min_list)).strip())


for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	h = y - x
	l = []
	for i in range(1, 51):
		if h % i == 0:
			l.append(h // i + 1)
	mid = -1
	for j in range(len(l)):
		if l[j] <= n:
			mid = l[j]
			break
	diff = h // (mid - 1)
	ans = [x]
	n -= mid
	mid -= 1
	while mid > 0:
		ans.append(ans[-1] + diff)
		mid -= 1
	while n > 0 and ans[0] - diff > 0:
		ans.insert(0, ans[0] - diff)
		n -= 1
	while n > 0:
		ans.append(ans[-1] + diff)
		n -= 1
	print(*ans)


import math
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	arr = []
	answer = [9999999]
	r = y - x
	d = []
	for i in range(1, 51):
		if r % i == 0:
			d.append(i)
	while True:
		arr = [y]
		for dd in range(len(d)):
			k = d[dd]
			arr = [y]
			for i in range(150):
				if arr[0] - k * (n - 1) < 1:
					arr[0] += k
				else:
					break
			for i in range(n - 1):
				arr.append(arr[i] - k)
			if arr.count(x) != 0:
				if arr[0] < answer[0]:
					answer = arr * 1
		else:
			break
	for i in range(n):
		print(answer[i], end=' ')
	print()


for t in range(int(input())):
	(n, ln, hn) = map(int, input().split())
	d = hn - ln
	count = 0
	for i in range(1, d + 1):
		if d % i == 0:
			l1 = []
			for j in range(n):
				r = hn - j * i
				if r < 1:
					break
				l1.append(r)
			if l1.count(ln) == 1:
				count = 1
				d1 = d
				break
	if count == 1:
		for i in range(len(l1)):
			print(l1[i], end=' ')
		if len(l1) < n:
			for i in range(n - len(l1)):
				l1.sort()
				d1 = l1[1] - l1[0]
				print(max(l1) + (i + 1) * d1, end=' ')
	print('\n')


t = int(input(''))
arr = []
for i in range(t):
	arr.append(list(map(int, input().split())))
for m in arr:
	n = m[0]
	x = m[1]
	y = m[2]
	diff = y - x
	for j in range(1, diff + 1):
		if (y - x) % j == 0 and (y - x) / j < n:
			diff = j
			break
	pos = y
	sol = []
	while pos > 0:
		sol.append(pos)
		pos -= diff
		if len(sol) == n:
			break
	pos = y + diff
	while len(sol) < n:
		sol.append(pos)
		pos += diff
	print(*sol)


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	d = y - x
	min_sum = float('inf')
	min_g = -1
	min_l = -1
	for i in range(n - 1, 0, -1):
		if d % i == 0:
			g = d // i
			l = min(n - 1 - i, (x - 1) // g)
			r = n - 1 - i - l
			lv = x - l * g
			rv = y + l * g
			s = (lv + rv) * n // 2
			if s < min_sum:
				min_sum = s
				min_g = g
				min_l = lv
	result = []
	for i in range(n):
		result.append(min_l + i * min_g)
	print(' '.join(list(map(str, result))))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = None
	for i in range(1, n + 1):
		for j in range(i + 1, n + 1):
			if (y - x) % (j - i) == 0:
				temp = (y - x) // (j - i)
				if d == None or temp <= d:
					d = temp
	ini = y
	l = []
	cnt = 0
	while ini > 0:
		l.append(ini)
		cnt += 1
		ini -= d
		if cnt == n:
			break
	ini = y + d
	while cnt != n:
		l.append(ini)
		ini += d
		cnt += 1
	for i in range(n):
		print(l[i], end=' ')
	print('')


from math import gcd
from collections import defaultdict
from sys import stdout
t = int(input())
for _ in range(t):
	(a, b, c) = map(int, input().split())
	z = c - b
	num = 1
	for i in range(a - 1, 0, -1):
		if z % i == 0:
			num = i
			break
	r = z // num
	for i in range(num + 1):
		stdout.write(str(b + i * r) + ' ')
	a -= num + 1
	while a > 0 and b - r > 0:
		stdout.write(str(b - r) + ' ')
		b -= r
		a -= 1
	while a > 0:
		stdout.write(str(c + r) + ' ')
		c += r
		a -= 1
	stdout.write('\n')


def ans_f(n, x, y):
	t1 = y - x
	an = []
	for r in range(n, 1, -1):
		for l in range(1, r):
			if t1 / (r - l) % 1 == 0:
				d = t1 // (r - l)
				a = x - (l - 1) * d
				if a > 0:
					for i in range(n):
						an.append(a + d * i)
					return an
t = int(input())
ans = []
for i in range(t):
	(n, x, y) = [int(i) for i in input().split()]
	ans.append(ans_f(n, x, y))
for i in ans:
	print(*i)


from collections import deque
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = -1
	for i in range(n - 1, 0, -1):
		if (y - x) % i == 0:
			ans = i
			break
	d = (y - x) // i
	rem = n
	q = deque([])
	last = x
	while last <= y:
		q.append(last)
		last += d
		rem -= 1
	last = x - d
	while rem and last > 0:
		q.appendleft(last)
		last -= d
		rem -= 1
	last = y + d
	while rem:
		q.append(last)
		last += d
		rem -= 1
	while q:
		print(q.popleft(), end=' ')
	print()


import math as mt
import sys, string
from collections import Counter, defaultdict
input = sys.stdin.readline
I = lambda : int(input())
M = lambda : map(int, input().split())
ARR = lambda : list(map(int, input().split()))

def main():
	(n, x, y) = M()
	d = y - x
	ds = []
	for i in range(1, d + 1):
		if d % i == 0:
			ds.append(i)
	for d in ds:
		arr = set()
		cnt = 0
		while y not in arr:
			arr.add(x + cnt * d)
			cnt += 1
		if len(arr) < n:
			c1 = -1
			while len(arr) < n and x + c1 * d > 0:
				arr.add(x + c1 * d)
				c1 -= 1
			while len(arr) < n:
				arr.add(x + cnt * d)
				cnt += 1
		if len(arr) == n:
			for e in arr:
				print(e, end=' ')
			print()
			return
tc = I()
for _ in range(tc):
	main()


for _ in range(int(input())):
	(n, x, y) = [int(x) for x in input().split()]
	for i in range(y - x, 0, -1):
		if (y - x) % i == 0 and i <= n - 1:
			intervalos = i
			break
	k = int((y - x) / intervalos)
	if n - 1 - intervalos > 0:
		if x >= k:
			intervalos_minimo = min(n - 1 - intervalos, int(x / k))
			minimo = x - intervalos_minimo * k
			if minimo == 0:
				minimo = minimo + k
				intervalos_minimo = intervalos_minimo - 1
			if n - 1 - intervalos - intervalos_minimo > 0:
				maximo = (n - 1 - intervalos - intervalos_minimo) * k + y
			else:
				maximo = y
		else:
			minimo = x
			maximo = y + (n - 1 - intervalos) * k
	else:
		minimo = x
		maximo = y
	for i in range(minimo, maximo + k, k):
		print(i, end=' ')


t = int(input())
i = 0
while i < t:
	A = list(map(int, input().split()))
	n = A[0]
	x = A[1]
	y = A[2]
	razn = y - x
	R = []
	j = 1
	while j <= razn:
		if razn % j == 0:
			R.append(j)
		j += 1
	delit = 0
	for j in R:
		if j * (n - 1) >= razn:
			delit = j
			break
	answer = []
	DEL1 = 0
	DEL2 = delit
	while n > 0:
		if y - DEL1 > 0:
			answer.append(y - DEL1)
			DEL1 += delit
		else:
			answer.append(y + DEL2)
			DEL2 += delit
		n -= 1
	ANS = ''
	for j in answer:
		ANS += str(j) + ' '
	print(ANS)
	i += 1


import math

def f(n, x, y):
	m = math.ceil((y - x) / (n - 1))
	d = y - x
	for i in range(m, y - x + 1):
		if (y - x) % i == 0:
			d = i
			break
	if x % d == 0:
		c = max(y - min(math.floor(y / d), n - 1) * d, d)
	else:
		c = max(y - min(math.floor(y / d), n - 1) * d, x % d)
	s = ''
	for i in range(0, n):
		s = s + str(c + d * i) + ' '
	return s
t = int(input())
a = [None] * t
for i in range(0, t):
	a[i] = [int(x) for x in input().split()]
for i in range(0, t):
	print(f(a[i][0], a[i][1], a[i][2]))


import sys
import math
import itertools
import functools
import collections
import operator
import fileinput
import copy
ORDA = 97

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

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

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

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

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

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=2):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

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

def convn(number, base):
	new_number = 0
	while number > 0:
		new_number += number % base
		number //= base
	return new_number

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

def ispal(s):
	for i in range(len(s) // 2 + 1):
		if s[i] != s[-i - 1]:
			return False
	return True

def main():
	for i in range(ii()):
		(n, x, y) = mi()
		lst = [x, y]
		if (y - x) % (n - 1) == 0:
			d = (y - x) // (n - 1)
			for i in range(1, n - 1):
				lst.append(x + i * d)
		else:
			for i in range(n - 2, 0, -1):
				if (y - x) % i == 0:
					d = (y - x) // i
					break
			z = x + d
			while z < y:
				lst.append(z)
				z += d
			if len(lst) < n and x - d >= 1:
				l = len(lst)
				z = x - d
				while l != n and z >= 1:
					lst.append(z)
					z -= d
					l += 1
			if len(lst) < n:
				l = len(lst)
				z = y + d
				while l != n:
					lst.append(z)
					z += d
					l += 1
		print(*lst)
main()


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	span = 0
	for i in range(1, 50):
		if (y - x) % i == 0 and n >= (y - x) // i + 1:
			span = i
			break
	ans = []
	for i in range(x, y + 1, span):
		ans.append(i)
	nmid = (y - x) // span + 1
	nleft = n - nmid
	for i in range(nleft):
		if x - span * (i + 1) > 0:
			ans.append(x - span * (i + 1))
		else:
			break
	nright = n - len(ans)
	for i in range(nright):
		ans.append(y + span * (i + 1))
	print(*ans)


t = int(input())

def solve(n, x, y):
	_dif = y - x
	cur_n = n - 1
	while _dif % cur_n:
		cur_n -= 1
	step = _dif // cur_n
	core = [x]
	for _ in range(cur_n):
		core.append(core[-1] + step)
	left = n - len(core)
	while left:
		prev = core[0] - step
		if prev <= 0:
			break
		left -= 1
		core.insert(0, prev)
	while left:
		core.append(core[-1] + step)
		left -= 1
	return ' '.join(map(str, core))
for _ in range(t):
	args = [int(x) for x in input().split(' ')]
	print(solve(*args))


import sys
import math
import heapq
import collections

def inputnum():
	return int(input())

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

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

def inputstring():
	return [x for x in input()]

def inputstringnum():
	return [ord(x) - ord('a') for x in input()]

def inputmatrixchar(rows):
	arr2d = [[j for j in input().strip()] for i in range(rows)]
	return arr2d

def inputmatrixint(rows):
	arr2d = []
	for _ in range(rows):
		arr2d.append([int(i) for i in input().split()])
	return arr2d
t = int(input())
for q in range(t):
	(n, x, y) = inputnums()
	m = y - x
	diff = 0
	for i in range(1, 50):
		if m % i == 0 and m // i < n:
			diff = i
			break
	m //= i
	indy = 0
	for i in range(0, 49):
		if i + m < n and y - (i + m) * diff > 0:
			indy = i + m
	start = y - indy * diff
	for i in range(n):
		print(start, end=' ')
		start += diff
	print()


for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	best = []
	bm = 10 ** 9
	for diff in range(1, 50):
		curr = [x, y]
		if (y - x) % diff == 0:
			for i in range(x + diff, y, diff):
				curr.append(i)
			if len(curr) <= n:
				for i in range(x - diff, 0, -diff):
					if len(curr) < n:
						curr.append(i)
				cc = y + diff
				while len(curr) < n:
					curr.append(cc)
					cc += diff
				if bm > max(curr):
					best = curr
					bm = max(curr)
	print(' '.join(map(str, best)))


def solve(n, M, m):
	diff = M - m
	print(m, end=' ')
	n -= 1
	if n >= diff:
		for i in range(m + 1, M + 1):
			print(i, end=' ')
			n -= 1
		if n > 0:
			for i in range(m - 1, 0, -1):
				print(i, end=' ')
				n -= 1
				if n == 0:
					break
		if n > 0:
			for i in range(M + 1, M + n + 1):
				print(i, end=' ')
				n -= 1
				if n == 0:
					break
	else:
		step = 2
		while diff % step != 0 or diff // step > n:
			step += 1
		for i in range(m + step, M + 1, step):
			print(i, end=' ')
			n -= 1
		if n > 0:
			for i in range(m - step, 0, -step):
				print(i, end=' ')
				n -= 1
				if n == 0:
					break
		if n > 0:
			for i in range(M + step, M + step * n + 1, step):
				print(i, end=' ')
				n -= 1
				if n == 0:
					break
	print()

def main():
	t = int(input())
	for _ in range(t):
		(n, x, y) = list(map(int, input().split()))
		solve(n, max(x, y), min(x, y))
main()


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	if y <= n:
		print(*range(1, n + 1))
	elif 1 + y - n > x:
		for p in range(n, 1, -1):
			if (y - x) % (p - 1) == 0:
				c = (y - x) // (p - 1)
				kuch = 0
				while x - (n - p - kuch) * c <= 0:
					kuch += 1
				ft = x - (n - p - kuch) * c
				lt = ft + (n - 1) * c
				print(*range(x - (n - p - kuch) * c, lt + 1, c))
				break
		val = (y - x) // (n - 1)
	else:
		print(*range(1 + (y - n), y + 1))


import sys
input = sys.stdin.readline

def solve():
	(n, x, y) = map(int, input().split())
	arr = []
	for i in range(1, n):
		if (y - x) % i == 0:
			step = (y - x) // i
			smol = x % step
			if smol == 0:
				smol += step
			total = smol + step * (n - 1)
			arr.append((max(total, y), step))
	(total, step) = min(arr)
	print(*range(total - step * (n - 1), total + 1, step))
for _ in range(int(input())):
	solve()


def divisors(a: int) -> list:
	out = []
	for i in range(1, a + 1):
		if a % i == 0:
			out.append(i)
	return out
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	dif = y - x
	for d in range(1, dif + 1):
		if dif % d or n * d < dif:
			continue
		top = max(y, (n - (1 if y % d else 0)) * d + y % d)
		low = top - (n - 1) * d
		if x < low or low < 0:
			continue
		break
	arr = [a for a in range(low, top + 1, d)]
	print(*arr)


def binary(a, x):
	(l, r) = (0, n - 1)
	while l <= r:
		m = (l + r) // 2
		if a[m] == x:
			return True
		elif a[m] < x:
			l = m + 1
		else:
			r = m - 1
	return False
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = []
	for i in range(1, 51):
		for j in range(1, 51):
			mas = list(range(i, i + j * (n - 1) + 1, j))
			if binary(mas, x) and binary(mas, y):
				ans.append(mas)
				break
	ans.sort(key=lambda x: x[n - 1])
	print(*ans[0])


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	p = n - 2
	q = y - x
	j = p
	m = q % (j + 1)
	while j >= 0:
		m = q / (j + 1)
		if m == round(m):
			break
		elif m != round(m):
			j -= 1
	l = []
	a = p - j
	l.append(x)
	l.append(y)
	for k in range(j):
		l.append(int(x + (k + 1) * m))
	an = x - m
	while a != 0 and an > 0:
		l.append(int(an))
		an -= m
		a -= 1
	an = y + m
	while a != 0:
		l.append(int(an))
		an += m
		a -= 1
	for j in l:
		print(j, end=' ')
	print('')


from collections import *
from sys import *
input = stdin.readline
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = y - x
	ans = -1
	for i in range(1, d + 1):
		if d % i == 0:
			if d // i < n:
				ans = i
				break
	a = deque([])
	k = n - (d // ans + 1)
	val = x - ans
	while k > 0 and val > 0:
		k -= 1
		a.appendleft(val)
		val -= ans
	for i in range(x, y + 1, ans):
		a.append(i)
	val = y
	while k > 0:
		val += ans
		k -= 1
		a.append(val)
	a = list(a)
	print(*a)


import math
for z in range(int(input())):
	(n, x, y) = map(int, input().split())
	k = y - x
	d = n - 1
	while True:
		if k % d == 0:
			break
		d -= 1
	d = int(k / d)
	if int(math.ceil(y / d)) >= n:
		a = y - (n - 1) * d
		for i in range(0, n):
			print(a + i * d, end=' ')
	else:
		if y % d:
			a = y - y // d * d
		else:
			a = d
		for i in range(0, n):
			print(a + i * d, end=' ')
	print()


t = int(input())
for tt in range(t):
	(n, x, y) = [int(i) for i in input().split(' ')]
	ans = 999999999
	for i in range(y - x):
		i += 1
		if (y - x) % i or (y - x) // i > n - 1:
			continue
		be = (x - 1) % i + 1
		if be + (n - 1) * i < y:
			be = y - (n - 1) * i
		if be + (n - 1) * i < ans:
			(ans, k, s) = (be + (n - 1) * i, i, be)
	print(' '.join([str(x * k + s) for x in range(n)]))


import sys
sys.setrecursionlimit(10 ** 5)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

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

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

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

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def SI():
	return sys.stdin.readline()[:-1]

def factors(a):
	res = []
	for d in range(1, a + 1):
		if d ** 2 > a:
			break
		if a % d:
			continue
		res.append(d)
		res.append(a // d)
	if res[-1] == res[-2]:
		res.pop()
	return res

def cal(d):
	pre = (x - 1) // d
	mid = (y - x) // d + 1
	if mid > n:
		return 10 ** 16
	if pre + mid >= n:
		return y
	return d * (n - pre - mid) + y
for _ in range(II()):
	(n, x, y) = MI()
	mx = 10 ** 16
	ansd = -1
	for d in factors(y - x):
		cur = cal(d)
		if cur < mx:
			mx = cur
			ansd = d
	ans = []
	for _ in range(n):
		ans.append(mx)
		mx -= ansd
	print(*ans)


import math
for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	dif = y - x
	div = []
	i = 1
	while i * i <= dif:
		if dif % i == 0:
			div.append(i)
			if i * i != dif:
				div.append(dif // i)
		i += 1
	m = -99999999999
	for i in range(len(div)):
		if div[i] < n:
			m = max(div[i], m)
	step = dif // m
	needR = 1 + dif // step
	f = min(math.floor((x - 1) / step), n - needR)
	arr = [x - f * step]
	for i in range(1, n):
		arr.append(arr[-1] + step)
	print(*arr)


import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq 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')
ALPHA = 'abcdefghijklmnopqrstuvwxyz'
M = 998244353
EPS = 1e-06

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()]
for _ in range(Int()):
	(n, x, y) = value()
	max_d = y - x
	A = 0
	D = 0
	last = inf
	for d in range(1, max_d + 1):
		over = max_d // d + 1
		if max_d % d == 0 and over <= n:
			here_A = x
			while here_A - d > 0 and over < n:
				here_A -= d
				over += 1
			here = here_A + (n - 1) * d
			if here < last:
				last = here
				A = here_A
				D = d
	for i in range(n):
		print(A, end=' ')
		A += D
	print()


for i in range(int(input())):
	(n, x, y) = tuple(map(int, input().split()))
	a = []
	t = n - 1
	z = 0
	if n == 2:
		print(x, y)
	else:
		while t > 0:
			if (y - x) % t == 0:
				z = (y - x) // t
				break
			t -= 1
		for i in range(x, y + 1, z):
			a.append(i)
		if n > len(a):
			for i in range(x, 0, -z):
				if i != x:
					a.append(i)
			if n > len(a):
				t = 1
				while len(a) != n:
					a.append(y + t * z)
					t += 1
		for i in range(n):
			print(a[i], end=' ')
		print()


for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = 0
	start = 0
	for i in range(1, 51):
		for j in range(1, 51):
			st = j
			di = i
			st_b = False
			di_b = False
			for k in range(n):
				temp = st + k * di
				if temp == x:
					st_b = True
				if temp == y:
					di_b = True
			if st_b and di_b:
				break
		if st_b and di_b:
			diff = i
			start = j
			break
	for i in range(n):
		print(start + i * diff, end=' ')
	print()


for _ in [*open(0)][1:]:
	(n, x, y) = map(int, _.split())
	delta = -1
	k = int(y - x)
	for i in range(1, k + 1):
		if (y - x) % i == 0 and (y - x) // i + 1 <= n:
			delta = i
			break
	if delta == -1:
		delta = y - x
	print(*[y - min(n - 1, (y - 1) // delta) * delta + delta * i for i in range(n)])


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	ref = y - x
	ans = []
	for i in range(n - 1, 0, -1):
		if ref % i == 0:
			part = i
			break
	diff = ref // part
	for i in range(x, y + 1, diff):
		ans.append(i)
	for i in range(x - diff, 0, -diff):
		if len(ans) < n:
			ans.append(i)
		else:
			break
	u = y
	while len(ans) < n:
		u += diff
		ans.append(u)
	for u in ans:
		print(u, end=' ')
	print('')


from sys import stdin, stdout
t = int(stdin.readline())
for _ in range(t):
	(n, x, y) = map(int, stdin.readline().split())
	diff = max(x, y) - min(x, y)
	r = diff
	for i in range(n - 1, 0, -1):
		if diff % i == 0:
			r = diff // i
			break
	counter = 0
	c = max(x, y)
	while counter < n and c > 0:
		print(c, end=' ')
		c -= r
		counter += 1
	p = max(x, y)
	while counter < n:
		p += r
		print(p, end=' ')
		counter += 1
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	pla = y - x
	(nc, w) = (n - 1, 0)
	while True:
		if pla % nc == 0:
			d = pla // nc
			break
		else:
			nc -= 1
			w += 1
	res = []
	for i in range(x, y + 1, d):
		res.append(i)
	while w != 0:
		if min(res) - d > 0:
			res.append(min(res) - d)
			w -= 1
		else:
			res.append(max(res) + d)
			w -= 1
	print(*res)


for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		toadd = n - 1
		min = 100000000000
		d = y - x
		c = y // d + 1
		min = y + (n - c) * d
		k = d
		for i in range(2, n):
			if (y - x) % i == 0:
				d = (y - x) // i
				if y % d == 0:
					c = y // d
				else:
					c = y // d + 1
				if y + (n - c) * d < min:
					min = y + (n - c) * d
					k = d
		print(y, end=' ')
		(x2, y2) = (x, y)
		while toadd != 0:
			if y2 - k > 0:
				y2 -= k
				print(y2, end=' ')
			else:
				y += k
				print(y, end=' ')
			toadd -= 1
		print('')


def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	diff = y - x
	d = -1
	flag = 0
	for i in range(n - 1, 0, -1):
		if diff % i == 0:
			d = diff // i
			flag = 1
			break
	if flag == 0:
		d = diff
	l = []
	for i in range(x + d, y + 1, d):
		l.append(i)
	z = len(l)
	for i in range(x, 0, -d):
		if z < n:
			l.append(i)
			z += 1
		else:
			break
	j = y + d
	while z < n:
		l.append(j)
		z += 1
		j += d
	print(*l)


def main():
	tc = int(input().strip())
	for c in range(tc):
		(n, x, y) = [int(i) for i in input().split(' ')]
		if n == 2:
			print('{} {}'.format(x, y))
			continue
		target = n - 2
		diff = y - x
		for i in range(1, diff + 1):
			if diff % i == 0:
				factor = diff // i
				seps = factor - 1
				if seps <= target:
					target -= seps
					mn = x - target * i
					if mn < 1:
						mn = x - x // i * i
						if mn == 0:
							mn = i
					ans = [str(mn + i * idx) for idx in range(n)]
					print(' '.join(ans))
					break
main()


for s in [*open(0)][1:]:
	(n, x, y) = map(int, s.split())
	d = y - x
	i = 1
	while d % i or d // i >= n:
		i += 1
	x = max(x % i or i, y - n * i + i)
	print(*range(x, x + n * i, i))


def printAP(a, d, n):
	res = []
	curr_term = a
	for i in range(1, n + 1):
		res.append(curr_term)
		curr_term = curr_term + d
	return res
t = int(input())
while t > 0:
	(n, x, y) = map(int, input().split(' '))
	var = 100000
	arr = []
	for i in range(1, x + 1):
		for j in range(1, 51):
			k = printAP(i, j, n)
			if x in k and y in k and (max(k) < var):
				arr = k
				var = max(k)
	arr = list(map(str, arr))
	print(' '.join(arr))
	t -= 1


import math
from decimal import *
import random
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = []
	mx = int(1000000000.0)
	for i in range(1, 51):
		for j in range(1, max(x, y) + 1):
			arr = []
			pre = int(j)
			for k in range(n):
				arr.append(pre)
				pre += i
			if x in arr and y in arr:
				tm = max(arr)
				if tm < mx:
					ans = list(arr)
					mx = int(tm)
	for i in range(len(ans)):
		ans[i] = str(ans[i])
	print(' '.join(ans))


import math
for i in range(int(input())):
	a = [int(j) for j in input().split()]
	n = a[0]
	x = a[1]
	y = a[2]
	z = y - x
	j = 0
	c = 0
	for d in range(math.ceil(z / (n - 1)), z + 1):
		if z % d == 0:
			break
	while y - j * d > 0 and c < n:
		print(y - j * d, end=' ')
		j += 1
		c += 1
	if c != n:
		for k in range(n - c):
			print(y + (k + 1) * d, end=' ')
	print()


import sys
input = lambda : sys.stdin.readline().rstrip()
from math import ceil
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	chk = y - x
	div = set()
	for i in range(1, chk + 1):
		if chk % i == 0:
			div.add(i)
	div = list(div)
	div.sort()
	ans = []
	for i in div:
		ans.append([])
		for j in range(0, n):
			ans[-1].append(x + j * i)
	l = []
	c = 0
	for i in ans:
		if x in i and y in i:
			l.append(c)
		c += 1
	ans1 = []
	for i in range(len(ans)):
		if i in l:
			ans1.append(ans[i])
	ans1.sort()
	while len(ans1) > 1:
		ans1.pop()
	ans = ans1[0][:]
	add = []
	c = ans[0]
	d = ans[1] - ans[0]
	while ans[-1] > y and c - d > 0:
		ans.pop()
		add.append(c - d)
		c -= d
	print(*ans + add)


T = int(input())
ret = []
for t in range(T):
	(n, x, y) = map(int, input().split())
	for k in range(1, 50):
		if x % k != y % k:
			continue
		if not x + k * (n - 1) >= y:
			continue
		ans = [0] * n
		ans[0] = max(y - (n - 1) * k, y % k)
		if ans[0] == 0:
			ans[0] = k
		for i in range(1, n):
			ans[i] = ans[i - 1] + k
		break
	ret.append(ans)
for t in range(T):
	print(' '.join(list(map(str, ret[t]))))


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log2, ceil, pi, sin, cos, acos, atan
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from bisect import insort
from collections import Counter
from collections import deque
from heapq import heappush, heappop, heapify
from itertools import permutations, combinations
mod = int(1000000000.0) + 7
ip = lambda : int(stdin.readline())
inp = lambda : map(int, stdin.readline().split())
ips = lambda : stdin.readline().rstrip()
out = lambda x: stdout.write(str(x) + '\n')
t = ip()
for _ in range(t):
	(n, x, y) = inp()
	diff = abs(x - y)
	ans = []
	dic = {}
	for i in range(1, diff + 1):
		if diff % i == 0:
			arr = []
			nn = n
			for j in range(x, y + 1, i):
				arr.append(j)
			if len(arr) > n:
				pass
			else:
				st = x - i
				for j in range(st, 0, -i):
					if len(arr) == n:
						break
					else:
						arr.append(j)
				st = y
				while len(arr) != n:
					st += i
					arr.append(st)
				dic[max(arr)] = list(arr)
	ch = min(list(dic.keys()))
	ans = list(dic[ch])
	print(*ans)


cases = int(input())
for t in range(cases):
	(n, x, y) = list(map(int, input().split()))
	diff = y - x
	if diff % (n - 1) == 0:
		a = []
		v = diff // (n - 1)
		a.append(x)
		for i in range(n - 2):
			a.append(a[-1] + v)
		a.append(y)
		print(*a)
	else:
		c = n - 1
		while diff % c != 0:
			c -= 1
		v = diff // c
		if x - v <= 0:
			a = [x]
			for i in range(n - 1):
				a.append(a[-1] + v)
		else:
			a = [x]
			while a[-1] != y:
				a.append(a[-1] + v)
			left = n - len(a)
			st = []
			while x - v > 0 and left > 0:
				st.append(x - v)
				x -= v
				left -= 1
			a = st[::-1] + a
			while left > 0:
				a.append(a[-1] + v)
				left -= 1
		print(*a)


import math
tst = int(input())
t = 1
while t <= tst:
	(n, x, y) = map(int, input().split())
	d = y - x
	i = 1
	fg = 0
	while i <= d:
		if d % i == 0 and d / i + 1 <= n:
			while y - (d + i) > 0 and d / i + 1 < n:
				d += i
			x = y - d
			j = 1
			fg = 0
			while j <= n:
				fg = 1
				print(x, end=' ')
				x += i
				j += 1
		if fg == 1:
			break
		i += 1
	print('\r')
	t += 1


for T in range(int(input())):
	(n, x, y) = map(int, input().split())
	x_dup = x
	if n != 2:
		for i in range(1, 51):
			if (y - x) % i == 0:
				if (y - x) // i + 1 <= n:
					val = i
					c = (y - x) // i + 1
					break
		valo = 0
		for i in range(n - c, 0, -1):
			x -= val
			if x <= 0:
				valo = i
				break
			print(x, end=' ')
		x = x_dup
		for i in range(1, c + 1 + valo):
			print(x, end=' ')
			x += val
		print()
	else:
		print(x, y)


import sys
import math
input = sys.stdin.readline
from collections import deque
from queue import LifoQueue
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	that = 0
	for i in range(1, diff + 1):
		if diff % i == 0 and y - (n - 1) * i <= x:
			that = i
			break
	if that == 0:
		that = 1
	pp = y - (n - 1) * that
	if pp > 0:
		for i in range(n):
			print(pp + i * that, end=' ')
	else:
		for i in range(n):
			if pp + i * that > 0:
				pp = pp + i * that
				break
		for i in range(n):
			print(pp + i * that, end=' ')
	print()


import math
for _ in range(int(input())):
	(n, x, y) = [int(_) for _ in input().split()]
	for __ in range(1, y - x + 1):
		if (y - x) % __ == 0 and (y - x) // __ < n:
			break
	else:
		__ = y - x
	A = []
	for _ in range((y - x) // __ + 1):
		A.append(x + _ * __)
	n -= (y - x) // __ + 1
	i = 1
	while x - i * __ > 0 and n > 0:
		A.append(x - i * __)
		i += 1
		if n == 1:
			n = 0
			break
		n -= 1
	i = 1
	while n > 0:
		A.append(y + i * __)
		n -= 1
		i += 1
	for _ in A:
		print(_, end=' ')
	print()


t = int(input())
for _ in range(t):
	(n, x, y) = [int(x) for x in input().split()]
	cdk = y - x
	for i in range(1, cdk + 1):
		if cdk % i == 0 and (y - x) / (n - 1) <= i:
			cd = i
			break
	smallest = y - (n - 1) * cd
	if smallest <= 0:
		smallest = x
		while smallest - cd > 0:
			smallest -= cd
	ans = []
	for i in range(n):
		ans.append(smallest)
		smallest += cd
	print(' '.join([str(x) for x in ans]))


from math import *
d = [[1] for i in range(2, 51)]
d = [[0], [1]] + d
for i in range(2, 50):
	for j in range(i, 50, i):
		d[j].append(i)
for i in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	r = y - x
	for z in d[r]:
		if r // z > n - 1:
			continue
		elif r // z == n - 1:
			print(*[e for e in range(x, y + z, z)])
			break
		elif r // z < n - 1:
			if y - z * n > 0:
				print(*[e for e in range(y, y - z * n, -z)])
				break
			else:
				x = x - x // z * z if x - x // z * z > 0 else z
				print(*[e for e in range(x, x + z * n, z)])
				break


for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	z = n - 1
	d = None
	while z > 1:
		if (y - x) % z == 0:
			d = (y - x) // z
			break
		z -= 1
	if d is None:
		d = y - x
	arr = [x, y]
	count = 2
	(p1, p2, p3) = (True, False, False)
	last_added = x
	while count < n:
		if p1:
			if last_added + d >= y:
				p1 = False
				p2 = True
				last_added = x
			else:
				arr.append(last_added + d)
				last_added += d
				count += 1
		elif p2:
			if last_added - d <= 0:
				p2 = False
				p3 = True
				last_added = y
			else:
				arr.append(last_added - d)
				last_added -= d
				count += 1
		elif p3:
			arr.append(last_added + d)
			last_added += d
			count += 1
	print(' '.join(list(map(str, arr))))


import math
from collections import deque

def solve():
	(n, x, y) = map(int, input().split())
	ans_min = float('inf')
	ans_list = []
	for d in range(1, y - x + 1):
		if (y - x) % d == 0 and (y - x) // d + 1 <= n:
			l = [num for num in range(x, y + 1, d)]
			l = deque(l)
			while len(l) < n:
				first = l[0] - d
				if first > 0:
					l.appendleft(first)
				else:
					last = l[-1] + d
					l.append(last)
			if l[-1] < ans_min:
				ans_min = l[-1]
				ans_list = list(l)
	print(' '.join(map(str, ans_list)))
T = int(input())
for _ in range(T):
	solve()


for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	z = y - x
	j = n - 1
	i = 0
	while True:
		if z % (j - i) == 0:
			break
		i += 1
	d = z // (j - i)
	a = y - (n - 1) * d
	while a < 1 or a + (n - 1) * d < y:
		a += d
	i = 0
	while i < n:
		print(a + i * d, end=' ')
		i += 1
	print()


t = int(input())
for _ in range(t):
	[n, x, y] = [int(i) for i in input().split()]
	if (y - x) % (n - 1) == 0:
		u = (y - x) // (n - 1)
	else:
		u = 1 + (y - x) // (n - 1)
	d = u
	while (y - x) % d != 0:
		d += 1
	if x % d == 0:
		v = x // d - 1
	else:
		v = x // d
	k = (y - x) // d + 1
	if v + k - 1 >= n:
		s = x - (n - k) * d
	else:
		s = x - v * d
	a = [s + i * d for i in range(n)]
	print(*a)


import math

def factors(n):
	ans = []
	for i in range(1, int(math.sqrt(n)) + 1):
		if n % i == 0:
			ans.append(i)
			if i != n // i:
				ans.append(n // i)
	return sorted(ans)
t = int(input())
for _ in range(t):
	(n, x, y) = [int(i) for i in input().split()]
	diff = y - x
	facts = factors(diff)
	for d in facts:
		flag = False
		for i in range(1, x + 1):
			ans = [i]
			for j in range(n - 1):
				ans.append(ans[-1] + d)
			if x in ans and y in ans:
				flag = True
				break
		if flag:
			break
	for elem in ans:
		print(elem, end=' ')
	print()


import sys
input = sys.stdin.readline
I = lambda : list(map(int, input().split()))

def div(n):
	an = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			an.append(i)
			if n // i != i:
				an.append(n // i)
	return sorted(an)
(t,) = I()
for _ in range(t):
	(n, x, y) = I()
	d = y - x
	dv = div(d)
	an = []
	for j in dv:
		m = d // j + 1
		if m <= n:
			for i in range(x, y + 1, j):
				an.append(i)
			if len(an) < n:
				an = an[::-1]
				i = x - j
				while i > 0 and len(an) < n:
					an.append(i)
					i -= j
				an = an[::-1]
			if len(an) < n:
				i = y + j
				while i > 0 and len(an) < n:
					an.append(i)
					i += j
			break
	print(*an)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	for i in range(1, diff + 1):
		if diff % i:
			continue
		if diff / i + 1 > n:
			continue
		k = int(min((y - 1) / i, n - 1))
		a0 = y - k * i
		for j in range(n):
			print(a0 + j * i, end=' ')
		print('')
		break


for i in range(int(input())):
	(n, x, y) = [int(i) for i in input().split()]
	p = (y - x) / (n - 1)
	b = int(p) + 1
	for i in range(b, y - x + 1):
		if (y - x) % i == 0:
			cd = i
			break
	if int(p) == p:
		cd = int(p)
	ws = y - (y - 1) // cd * cd
	s = y - (n - 1) * cd
	s = max(ws, s)
	for i in range(n):
		print(s, ' ', end='')
		s = s + cd


import math

def solve(n, x, y):
	kd = y - x
	result = []
	minn = 0
	for k in range(1, kd + 1, 1):
		if kd % k != 0:
			continue
		d = kd // k
		a1 = y - d * (n - 1)
		if a1 > x:
			continue
		if a1 <= 0:
			m = -a1 // d + 1
			a1 += m * d
		an = a1 + d * (n - 1)
		if minn == 0 or an < minn:
			minn = an
			dd = d
	result = [an - dd * i for i in range(n)]
	return result
t = int(input())
for _ in range(t):
	(n, x, y) = (int(x) for x in input().split())
	print(*solve(n, x, y), sep=' ')


t = int(input())
while t:
	t -= 1
	(n, x, y) = map(int, input().split())
	for i in range(1, y - x + 1):
		if (y - x) % i == 0 and (y - x) // i < n:
			first = max(y - (n - 1) * i, (x - 1) % i + 1)
			for j in range(n):
				print(first + i * j, end=' ')
			print()
			break


int_inp = lambda : int(input())
strng = lambda : input().strip()
strl = lambda : list(input().strip())
mul = lambda : map(int, input().strip().split())
mulf = lambda : map(float, input().strip().split())
seq = lambda : list(map(int, input().strip().split()))
import math
from collections import Counter, defaultdict
for _ in range(int_inp()):
	(n, x, y) = mul()
	k = y - x
	a = []
	for i in range(1, y):
		if k / i <= n - 1 and k % i == 0:
			break
	maxx = y
	for j in range(1, n + 1):
		a.append(y)
		if y - i <= 0:
			for k in range(1, n - j + 1):
				maxx = maxx + i
				a.append(maxx)
			break
		y = y - i
	print(*a)


import math
import collections

def solve(n, x, y):
	ans = [50 + (y - x) * i for i in range(n)]
	for start in range(1, 51):
		for d in range(1, 51):
			new = [start + d * i for i in range(n)]
			if x in new and y in new:
				if new[-1] < ans[-1]:
					ans = new
	return ' '.join([str(i) for i in ans])
t = int(input())
for t in range(t):
	(n, x, y) = [int(s) for s in input().split()]
	result = solve(n, x, y)
	print(result)


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	d = y - x
	ansl = []
	ansv = 10 ** 9
	for i in range(1, d + 1):
		if d % i != 0:
			continue
		v = y
		to_front = True
		curr_ansl = [v]
		for _ in range(n - 1):
			if to_front:
				if v - i > 0:
					v -= i
					curr_ansl.append(v)
				else:
					to_front = False
					v = y + i
					curr_ansl.append(v)
			else:
				v += i
				curr_ansl.append(v)
		if min(curr_ansl) > x:
			continue
		mmax = max(curr_ansl)
		if mmax < ansv:
			ansv = mmax
			ansl = curr_ansl[:]
	ansl.sort()
	print(*ansl)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	maxn = y - x
	res = []
	lst = float('inf')
	for i in range(1, 51):
		for k in range(1, 51):
			tmp = []
			cnt = k
			tmp = [k + i * j for j in range(n)]
			if x not in tmp or y not in tmp:
				continue
			nsm = sum(tmp)
			if tmp[-1] < lst:
				res = tmp[:]
				lst = tmp[-1]
	print(*res)


import math
for _ in range(int(input())):
	(n, x, y) = [int(j) for j in input().split()]
	ans = 10 ** 9
	i1 = -1
	for i in range(1, y - x + 1):
		if (y - x) % i == 0 and (y - x) // i < n:
			k = (x - 1) // i
			if k > n - (y - x) // i - 1:
				ans = y
				i1 = i
				break
			if ans > y + i * (n - k - (y - x) // i - 1):
				ans = y + i * (n - k - (y - x) // i - 1)
				i1 = i
	l = [0 for i in range(n)]
	for i in range(n):
		l[i] = ans - i1 * i
	print(*l)


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 abs(x):
	return x if x >= 0 else -x

def binary_search(li, val, lb, ub):
	ans = 0
	while lb <= ub:
		mid = (lb + ub) // 2
		if li[mid] > val:
			ub = mid - 1
		elif val > li[mid]:
			lb = mid + 1
		else:
			ans = 1
			break
	return ans

def kadane(x):
	sum_so_far = 0
	current_sum = 0
	for i in x:
		current_sum += i
		if current_sum < 0:
			current_sum = 0
		else:
			sum_so_far = mpos(sum_so_far, current_sum)
	return sum_so_far

def pref(li):
	pref_sum = [0]
	for i in li:
		pref_sum.append(pref_sum[-1] + i)
	return pref_sum

def graph(n, m):
	adj = dict()
	for i in range(1, n + 1):
		adj.setdefault(i, 0)
	for i in range(m):
		(a, b) = map(int, input().split())
		adj[a] += 1
		adj[b] += 1
	return adj
import sys
import threading
from math import *
sys.setrecursionlimit(300000)
threading.stack_size(10 ** 8)
po = int(log(10 ** 18)) + 2
li = []
for i in range(po):
	li.append(3 ** i)
li = li[::-1]
s = sum(li)
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	a = max(x, y)
	b = min(x, y)
	first = 0
	d = 0
	for i in range(n - 1):
		d = (a - b) / (n - 1 - i)
		if d % 1 == 0:
			d = int(d)
			first = b - i * d
			break
		else:
			continue
	cnt = 0
	i = -1
	while cnt < n:
		i += 1
		if first + i * d > 0:
			print(first + i * d, end=' ')
			cnt += 1
	print('')


t = int(input())
while t > 0:
	t -= 1
	line = input().split(' ')
	n = int(line[0])
	x = int(line[1])
	y = int(line[2])
	gap = y - x
	chosen = 1
	for i in range(n - 1, 0, -1):
		if gap % i == 0:
			diff = gap / i
			chosen = i
			break
	diff = int(diff)
	ans = []
	for i in range(x, y + diff, diff):
		ans.append(i)
	while len(ans) < n:
		if ans[0] - diff > 0:
			ans.insert(0, ans[0] - diff)
		else:
			ans.append(ans[len(ans) - 1] + diff)
	_ans = ''
	for i in ans:
		_ans += str(int(i)) + ' '
	print(_ans.strip())


from sys import stdin, stdout
from collections import Counter
from itertools import permutations
import bisect
import math
I = lambda : map(int, stdin.readline().split())
I1 = lambda : stdin.readline()
for _ in range(int(I1())):
	(n, x1, y1) = I()
	x = max(x1, y1)
	y = min(x1, y1)
	for i in range(1, n):
		if (x - y) % (n - i) == 0:
			d = (x - y) // (n - i)
			a = y - (i - 1) * d
			if a >= 1:
				break
	if a <= 0:
		d = x - y
		m = 100000000
		for i in range(d, 0, -1):
			if d % i == 0:
				x1 = y
				c = 0
				while x1 >= 1:
					x1 -= i
					c += 1
				if y + (n - c) * i < m and y + (n - c) * i >= x:
					m = y + (n - c) * i
					d1 = i
		a = m - (n - 1) * d1
		for i in range(n):
			print(a, end=' ')
			a += d1
		print()
		continue
	for i in range(n):
		print(a, end=' ')
		a += d
	print()


def solve(n, x, y):
	diff = y - x
	max_elements_between_them = 0
	for i in range(n - 1, 0, -1):
		if diff % i != 0:
			pass
		else:
			max_elements_between_them = i - 1
			break
	common_diff = diff / (max_elements_between_them + 1)
	arr = [x, y]
	count = 2
	for i in range(max_elements_between_them):
		arr.append(x + common_diff * (i + 1))
	count += max_elements_between_them
	elem = x - common_diff
	i = 1
	while count < n and elem > 0:
		arr.append(x - i * common_diff)
		i += 1
		elem -= common_diff
		count += 1
	i = 1
	while count < n:
		arr.append(y + i * common_diff)
		i += 1
		count += 1
	arr = map(int, arr)
	arr = map(str, arr)
	return ' '.join(arr)
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	print(solve(n, x, y))


import sys, os
from io import BytesIO, IOBase
import collections, itertools, bisect, heapq, math, string
from decimal import *
BUFSIZE = 8192
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 main():
	t = int(input())
	for i in range(t):
		(n, x, y) = map(int, input().split())
		if n == 2:
			print(x, y)
			continue
		ans = []
		if (y - x) % (n - 1) == 0:
			temp = (y - x) // (n - 1)
			ans = [x + i * temp for i in range(n)]
			print(' '.join([str(a) for a in ans]))
			continue
		m = y - x
		for q in range(1, y - x + 1):
			if (y - x) % q == 0 and (y - x) // q <= n - 2:
				m = q
				break
		z = 0
		temp = x
		while True:
			temp = temp - m
			if temp <= 0 or z > n - 2 - (y - x) // m:
				break
			ans.append(temp)
			z += 1
		k = 0
		while n > z:
			ans.append(x + k * m)
			n = n - 1
			k += 1
		print(' '.join([str(a) for a in ans]))
main()


import sys
import math
from math import *
from collections import Counter, defaultdict, deque
lip = lambda : list(map(int, input().split()))
ip = lambda : int(input())
sip = lambda : input().split()

def main():
	(n, a, b) = lip()
	arr = [a, b]
	val = abs(a - b)
	if n > 2:
		sig = True
		i = 1
		num = -1
		while i < 50 and i < b:
			if val % i == 0 and val // i <= n - 1:
				num = i
				break
			i += 1
		if num > 0:
			cnt = 2
			while arr[-1] - num > a:
				arr.append(arr[-1] - num)
				cnt += 1
			temp = a
			while cnt < n and temp - num > 0:
				arr.append(temp - num)
				cnt += 1
				temp -= num
			temp = b
			while cnt < n:
				cnt += 1
				arr.append(temp + num)
				temp += num
	print(*arr)
for i in range(ip()):
	main()


import sys
import copy
input = sys.stdin.readline
t = int(input())
for case in range(t):
	(n, x, y) = map(int, input().split())
	ans = [0 for i in range(n)]
	mx = 1000000001
	for posx in range(n - 1):
		can = True
		mxt = 0
		for posy in range(posx + 1, n):
			mxt = 0
			can = True
			yes = False
			arr = [0 for i in range(n)]
			arr[posy] = y
			d = (y - x) // (posy - posx)
			for z in range(posy - 1, -1, -1):
				arr[z] = arr[z + 1] - d
				if arr[z] < 1:
					can = False
					break
				if arr[z] == x:
					yes = True
			if not can:
				continue
			if not yes:
				continue
			for z in range(posy + 1, n):
				arr[z] = arr[z - 1] + d
				mxt = max(mxt, arr[z])
			if mxt < mx:
				ans = copy.deepcopy(arr)
				mx = mxt
	print(*ans)


t = int(input())
for _ in range(t):
	(n, a, b) = map(int, input().split())
	n1 = n - 1
	f = 0
	diff = None
	while n1 > 0:
		if (b - a) % n1 == 0:
			f = 1
			diff = (b - a) // n1
			break
		n1 -= 1
	if f == 0:
		diff = b - a
	i = a
	c = 0
	while i <= b:
		print(i, end=' ')
		c += 1
		i += diff
	c = n - c
	i = a - diff
	while i > 0 and c > 0:
		print(i, end=' ')
		i -= diff
		c -= 1
	i = b + diff
	while c > 0:
		print(i, end=' ')
		i += diff
		c -= 1


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	f = 0
	cap = y - x
	d = 1
	h = {}
	ans = 10 ** 18
	while d <= cap:
		z = y - x
		if z % d == 0:
			t = n - z // d
			if t < 0:
				d = d + 1
				continue
			else:
				a = x + d - t * d
				cnt = 0
				while a <= 0:
					a = a + d
				l = []
				cnt = 0
				g = 0
				while cnt < n:
					if a == x or a == y:
						g += 1
					l.append(a)
					a = a + d
					cnt += 1
				if g != 2:
					d = d + 1
					continue
				e = l[-1]
				h[e] = l
				ans = min(ans, e)
				d = d + 1
		else:
			d = d + 1
	print(*h[ans])


import math
t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	for j in range(1, 51):
		if (y - x) % j == 0 and (y - x) / j < n:
			start = y
			m = n
			while start - j > 0 and m - 1 > 0:
				start -= j
				m -= 1
			print(start, end='')
			for k in range(n - 1):
				start += j
				print(' ', end='')
				print(start, end='')
			print()
			break


def calc(num):
	p = []
	for i in range(1, int(num ** 0.5) + 1):
		if num % i == 0:
			p.append(i)
			p.append(num // i)
	return p

def solve(diff):
	ans = []
	i = 0
	while len(ans) < n and (not ans or ans[-1] != y):
		ans.append(x + i * diff)
		i += 1
	i = 1
	flag = 0
	while len(ans) < n and ans[-1] > 0:
		ans.append(x - i * diff)
		flag = 1
		i += 1
	if ans[-1] <= 0:
		ans.pop()
	i = 1
	while len(ans) < n:
		ans.append(y + i * diff)
		i += 1
	if y not in ans:
		return [10 ** 18]
	return ans
for nt in range(int(input())):
	(n, x, y) = map(int, input().split())
	f = calc(y - x)
	m = 10 ** 18
	for i in f:
		arr = solve(i)
		if max(arr) < m:
			ans = arr
			m = max(arr)
	print(*ans)


n = int(input())
for i in range(n):
	(d, a, b) = list(map(int, input().split()))
	m = b - a
	z = []
	for i in range(1, 50):
		if m % i == 0:
			z.append(i)
	x = []
	t = max(a, b)
	for l in z:
		v = []
		for j in range(t, 0, -l):
			if len(v) >= d:
				break
			v.append(j)
		if len(v) < d:
			for o1 in range(50):
				if len(v) >= d:
					break
				t += l
				v.append(t)
		x.append(v)
	g = []
	for s in x:
		if a in s and b in s:
			g.append(s)
	if len(g) == 1:
		for c in g[0]:
			print(c, end=' ')
	else:
		e = []
		for w in g:
			e.append(max(w))
		y = min(e)
		for p in g:
			if max(p) == y:
				for c in p:
					print(c, end=' ')
				break


import sys
from typing import List, Union

def rl(int_: bool=True, is_split: bool=True) -> Union[List[str], List[int]]:
	if int_:
		return [int(w) for w in sys.stdin.readline().split()]
	if is_split:
		return [w for w in sys.stdin.readline().split()]
	return sys.stdin.readline().strip()
for _ in range(rl()[0]):
	(n, x, y) = rl()
	flag = True
	m = n
	while flag:
		d = (y - x) // (n - 1)
		if (n - 1) * d == y - x:
			flag = False
		else:
			n -= 1
	delta = m - n
	if delta == 0:
		print(' '.join(list(map(str, range(x, y + 1, d)))))
	else:
		l = list(range(x, y + 1, d))
		l = list(range(x, max(0, x - d * delta - 1), -d))[1:] + l
		delta -= (x - max(1, x - d * delta)) // d
		l += list(range(y + d * delta, y, -d))
		print(' '.join(map(str, l)))


import sys
INP = lambda : sys.stdin.readline().strip()
INT = lambda : int(INP())
MAP = lambda : map(int, INP().split())
ARR = lambda : [int(i) for i in INP().split()]

def JOIN(arr, x=' '):
	return x.join([str(i) for i in arr])

def EXIT(x='NO'):
	print(x)
	exit()
for _ in range(INT()):
	(n, x1, y) = MAP()
	dmax = y - x1
	ans = []
	lasts = []
	for d in range(1, dmax + 1):
		if dmax % d > 0:
			continue
		arr = [y - d * i for i in range(50)]
		arr = [x for x in reversed(arr) if x > 0]
		left = n - len(arr)
		if left > 0:
			arr = arr + [y + d * i for i in range(1, left + 1)]
		else:
			arr = list(reversed(list(reversed(arr))[:n]))
		assert len(arr) == n
		if x1 in arr:
			ans.append(arr)
			lasts.append(arr[-1])
	print(JOIN(ans[lasts.index(min(lasts))]))


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	if x < y:
		(x, y) = (y, x)
	for i in range(1, 50):
		if (x - y) % i != 0:
			continue
		mid_amount = (x - y) // i + 1
		if n < mid_amount:
			continue
		lower_amount = min((y - 1) // i, n - mid_amount)
		lower_val = y - lower_amount * i
		print(*list(range(lower_val, lower_val + n * i, i)))
		break


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = y - x
	(m, r) = (1, d)
	for i in range(n - 1, 0, -1):
		if d % i == 0:
			m = i
			r = int(d / i)
			break
	l = [i for i in range(x, y + 1, r)]
	n -= len(l)
	z = x - r
	while n > 0 and z > 0:
		n -= 1
		l.append(z)
		z -= r
	z = y + r
	while n > 0:
		l.append(z)
		n -= 1
		z += r
	print(' '.join([str(i) for i in l]))


t = int(input())
for i in range(t):
	(n, p, q) = map(int, input().split())
	ma = float('inf')
	ans = []
	for a in range(1, 50):
		for d in range(1, 50):
			ways = [a]
			j = n - 1
			while j > 0:
				ways.append(ways[-1] + d)
				j += -1
			if p in ways and q in ways:
				if max(ways) < ma:
					ma = max(ways)
					ans = ways
	print(*ans)


import sys
t = int(input())
for _ in range(t):
	(n, x, y) = list(map(int, input().split()))
	jump = y - x
	best = 999999999999999
	for i in range(1, int(jump ** 0.5) + 1):
		if jump % i == 0:
			(a, b) = (i, jump // i)
			arr = [a, b]
			for a in arr:
				tmp = [9999999999999999999]
				if a * (n - 1) >= jump:
					tmp = []
					for j in range(n):
						if y - j * a > 0:
							tmp.append(y - j * a)
					x = 1
					while len(tmp) < n:
						tmp.append(y + x * a)
						x += 1
				if max(tmp) < best:
					ans = tmp
					best = max(tmp)
	print(*ans)


for tc in range(int(input())):
	(n, x, y) = [int(x) for x in input().split()]
	diff = y - x
	segCount = n - 1
	d = 0
	for i in range(50, 0, -1):
		if diff % i == 0:
			if segCount < diff // i:
				break
			d = i
	segCount -= diff // d
	arr = []
	for i in range(x, y + 1, d):
		arr.append(i)
	x -= d
	while segCount > 0 and x > 0:
		arr.append(x)
		segCount -= 1
		x -= d
	while segCount > 0:
		y += d
		arr.append(y)
		segCount -= 1
	print(*arr)


T = int(input())
for i in range(T):
	arr = []
	(N, x, y) = map(int, input().split())
	n = float(N)
	while True:
		diff = (y - x) / (n - 1)
		if diff % 1 != 0:
			n = n - 1
		else:
			break
	j = 0
	for i in range(N):
		ext = int(y - i * diff)
		if ext > 0:
			arr.append(ext)
		else:
			j = j + 1
			arr.append(int(y + j * diff))
	for i in range(len(arr)):
		print(arr[i], end=' ')
	print('')


import sys
input = sys.stdin.readline

def div(n):
	res = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			res.append(i)
			if n // i != i:
				res.append(n // i)
	res.sort()
	return res
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	for i in div(y - x):
		if y <= x + n * i - 1:
			k = i
			break
	cnt = 0
	for i in range(x, y + 1, k):
		print(i, end=' ')
		cnt += 1
	while cnt < n:
		if x - k > 0:
			x -= k
			print(x, end=' ')
			cnt += 1
		else:
			y += k
			print(y, end=' ')
			cnt += 1
	print()


import sys
from functools import reduce
from collections import Counter
import time
import datetime
from math import sqrt, gcd

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

def sip():
	return sys.stdin.readline()

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

def mips():
	return map(str, sys.stdin.readline().split())

def lip():
	return list(map(int, sys.stdin.readline().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)

def check_prime(n):
	if n < 2:
		return False
	for i in range(2, int(n ** 0.5) + 1, 2):
		if n % i == 0:
			return False
	return True
t = ip()
while t:
	t -= 1
	(n, x, y) = mip()
	count = 0
	if n == 2:
		print(x, y)
	else:
		flag = 10 ** 18
		for i in range(1, 52):
			for d in range(1, 52):
				lst = []
				for j in range(i, i + d * n, d):
					lst.append(j)
				if x in lst and y in lst:
					if max(lst) < flag:
						flag = max(lst)
						arr = lst
		print(*arr)


from collections import deque
from math import sqrt

def factors(h):
	b = deque()
	c = deque()
	for x in range(1, int(sqrt(h) + 1)):
		if h % x == 0:
			b.append(x)
			if x != h // x:
				c.append(h // x)
	for x in range(len(c) - 1, -1, -1):
		b.append(c[x])
	return list(b)
t = int(input())
while t:
	(n, x, y) = map(int, input().split())
	h = y - x
	a = factors(h)
	l = len(a)
	diff = 0
	for k in range(l):
		if n * a[k] > h:
			diff = a[k]
			break
	d = deque()
	d.append(x)
	u = x
	while u != y:
		u += diff
		d.append(u)
	l = len(d)
	u = x - diff
	while l < n and u > 0:
		d.appendleft(u)
		u -= diff
		l += 1
	u = y + diff
	while l < n:
		d.append(u)
		u += diff
		l += 1
	for k in range(n):
		print(d[k], end=' ')
	print()
	t -= 1


import os
import sys
from io import BytesIO, IOBase

def main():
	t = int(input())
	for _ in range(t):
		chk = 0
		(n, x, y) = map(int, input().split(' '))
		for xx in range(1, 100):
			for yy in range(1, 100):
				ans = []
				for zz in range(n):
					ans.append(yy + xx * zz)
				if y in ans and x in ans:
					chk = 1
					break
			if chk == 1:
				break
		print(*ans)
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')
main()


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

def fun(x, y, z, r):
	ch = 0
	for i in range(x, y + 1, r):
		ch += 1
		if i == y and ch <= z:
			return r
	return 0
for _ in range(I()):
	(n, x, y) = M()
	b = y - x - 1
	if n - 2 >= b:
		c = []
		for i in range(x, y + 1):
			c += [i]
			n -= 1
		for i in range(x - 1, 0, -1):
			if n <= 0:
				break
			c += [i]
			n -= 1
		for i in range(y + 1, 100000):
			if n <= 0:
				break
			c += [i]
			n -= 1
		print(*c)
	else:
		c = [x, y]
		for i in range(1, 50):
			d = fun(x, y, n, i)
			if d:
				break
		if d == 0:
			d = 10000
		for i in range(x, y + 1, d):
			if n <= 0:
				break
			c += [i]
			n -= 1
		for i in range(max(0, x - d), 0, -d):
			if n <= 0:
				break
			c += [i]
			n -= 1
		val = y + d
		while n > 0:
			c += [val]
			val += d
			n -= 1
		print(*list(set(c)))


import math
import re
import itertools
import copy
import time
import sys

def input_linear(lamb=lambda x: int(x), seperator=' '):
	return map(lamb, input().split(seperator))

def input_array(lamb=lambda x: int(x), seperator=' '):
	return list(map(lamb, input().split(seperator)))

def input_matrix(rows, lamb=lambda x: int(x), seperator=' '):
	tmp_matrix = []
	for i in range(rows):
		tmp_matrix.append(input_array(lamb, seperator))
	return tmp_matrix

def input_graph_al_pair(vertices, lines, lamb=lambda x: int(x), seperator=' ', directional=False, remove_dup=False):
	temp_matrix = [x[:] for x in [[]] * vertices]
	if not directional:
		if not remove_dup:
			for i in range(lines):
				(ina, inb) = input_linear(lamb, seperator)
				temp_matrix[ina].append(inb)
				temp_matrix[inb].append(ina)
		else:
			for i in range(lines):
				(ina, inb) = input_linear(lamb, seperator)
				if inb not in temp_matrix[ina]:
					temp_matrix[ina].append(inb)
				if ina not in temp_matrix[inb]:
					temp_matrix[inb].append(ina)
		return temp_matrix
	else:
		if not remove_dup:
			for i in range(lines):
				(ina, inb) = input_linear(lamb, seperator)
				temp_matrix[ina].append(inb)
		else:
			for i in range(lines):
				(ina, inb) = input_linear(lamb, seperator)
				if inb not in temp_matrix[ina]:
					temp_matrix[ina].append(inb)
		return temp_matrix
for _ in range(int(input())):
	curr = [0, 0, math.inf, 0]
	(n, x, y) = input_linear()
	if x == y:
		print(' '.join(list(map(str, [x] * n))))
	if x > y:
		(x, y) = (y, x)
	else:
		for a1 in range(0, n - 1):
			for a2 in range(a1 + 1, n):
				if (y - x) % (a2 - a1) != 0:
					continue
				d = (y - x) / (a2 - a1)
				sta = x - a1 * d
				if sta <= 0:
					continue
				if sta + (n - 1) * d < curr[2]:
					curr = [a1, a2, sta + (n - 1) * d, sta, d]
	dod = int(curr[4])
	star = int(curr[3])
	for i in range(n):
		print(star + dod * i, end=' ')
	print('')


import atexit
import io
import sys
_INPUT_LINES = sys.stdin.read().splitlines()
inp = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER

@atexit.register
def write():
	sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
inar = lambda : list(map(int, inp().split()))
inin = lambda : int(inp())
inst = lambda : inp().decode().strip()

def all_factors(n):
	(small, large) = ([], [])
	for i in range(1, int(n ** 0.5) + 1, 2 if n & 1 else 1):
		if not n % i:
			small.append(i)
			large.append(n // i)
	if small[-1] == large[-1]:
		large.pop()
	large.reverse()
	small.extend(large)
	return small
_T_ = inin()
for _t_ in range(_T_):
	(n, x, y) = inar()
	a = all_factors(y - x)
	val = 0
	for i in a:
		if x + (n - 1) * i >= y:
			val = i
			break
	else:
		print('-1')
	ans = []
	count = 0
	next_ = y
	while next_ >= 1:
		ans.append(next_)
		next_ -= val
		count += 1
	next_ = y + val
	for i in range(max(0, n - len(ans))):
		ans.append(next_)
		next_ += val
	ans.sort()
	print(*ans[-n:])


import sys

def Step_Available(left, dif):
	if left >= dif - 1:
		step = 1
		availableIn = dif
	else:
		diviseur = max(diviseurs(dif, left + 1))
		step = dif // diviseur
		availableIn = diviseur - 1
	return (step, availableIn)

def diviseurs(dividende, limite):
	lis = []
	for i in range(1, limite + 1):
		if dividende % i == 0:
			lis.append(i)
	return lis

def secretArray(n, x, y):
	left = n - 2
	dif = y - x
	minimum = x
	if left == 0:
		secretAr = [x, y]
	else:
		(step, available) = Step_Available(left, dif)
		availableIn = dif // step - 1
		leftOut = left - availableIn
		for i in range(leftOut, 0, -1):
			if x - step * i > 0:
				minimum = x - step * i
				break
		secretAr = [minimum + i * step for i in range(n)]
	return secretAr
output = []
for line in sys.stdin:
	t = int(line)
	break
for line in sys.stdin:
	try:
		(n, x, y) = [int(x) for x in line.split()]
		output.append(secretArray(n, x, y))
	except:
		m = [int(x) for x in line.split()]
for testResult in output:
	print(' '.join(map(str, testResult)))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n >= y:
		print(*list(range(1, n + 1)))
	elif n == 2:
		print(x, y)
	else:
		ans = []
		for diff in range(1, 51):
			if y - diff * n < x and (y - x) % diff == 0:
				ref = y
				while y > 0 and n:
					ans.append(y)
					y -= diff
					n -= 1
				while n:
					ans.append(ref + diff)
					ref += diff
					n -= 1
		print(*ans)


t = int(input())
for _ in range(t):
	(n, x, y) = list(map(int, input().split()))
	d = y - x
	for i in range(1, n):
		if (y - x) % i == 0:
			d = min(d, (y - x) // i)
	ans = []
	p = x
	while p <= y and n > 0:
		ans.append(p)
		p = p + d
		n = n - 1
		if p > y:
			break
	p = x - d
	while p > 0 and n > 0:
		ans.append(p)
		p = p - d
		n = n - 1
	p = y + d
	while n > 0:
		ans.append(p)
		p = p + d
		n = n - 1
	print(*ans)


import math
t = int(input())
for j in range(t):
	(n, x, y) = map(int, input().split())
	f = y - x
	a = 0
	for j in range(n - 1, 0, -1):
		if f % j == 0:
			f = f // j
			a = j
			break
	r = x % f
	if r == 0:
		r = f
	ans = []
	for j in range(r, max(y + 1, r + (n - 1) * f + 1), f):
		ans.append(j)
	print(*ans[::-1][:n])


for _ in ' ' * int(input()):
	(n, x, y) = map(int, input().split())
	(num, cnt) = (n, 0)
	n -= 1
	while (y - x) % n != 0:
		n -= 1
	fac = (y - x) // n
	for i in range(x, y + 1, fac):
		print(i, end=' ')
		cnt += 1
	while cnt < num and x - fac > 0:
		print(x - fac, end=' ')
		x -= fac
		cnt += 1
	while cnt < num:
		print(y + fac, end=' ')
		y += fac
		cnt += 1
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	lst = []
	for d in range(1, y - x + 1):
		if (y - x) % d == 0:
			if (y - x) // d <= n - 1:
				for j in range((y - x) // d):
					lst.append(x + j * d)
				lst.append(y)
				break
	if len(lst) != n:
		n -= len(lst)
		x -= d
		while x > 0 and n > 0:
			lst.append(x)
			n -= 1
			x -= d
		y += d
		while n > 0:
			n -= 1
			lst.append(y)
			y += d
	print(*lst)


import math

def input_linear(l=lambda x: int(x), seperator=' '):
	return map(l, input().split(seperator))
for _ in range(int(input())):
	c = [0, 0, math.inf, 0]
	(n, a, b) = input_linear()
	if a == b:
		print(' '.join(list(map(str, [a] * n))))
	if a > b:
		(x, b) = (b, a)
	else:
		for aa in range(0, n - 1):
			for an in range(aa + 1, n):
				if (b - a) % (an - aa) != 0:
					continue
				d = (b - a) / (an - aa)
				sa = a - aa * d
				if sa <= 0:
					continue
				if sa + (n - 1) * d < c[2]:
					c = [aa, an, sa + (n - 1) * d, sa, d]
	da = int(c[4])
	s = int(c[3])
	for i in range(n):
		print(s + da * i, end=' ')
	print(' ')


t = int(input())
while t:
	t -= 1
	(n, x, y) = map(int, input().split())
	ans = []
	d = y - x
	for i in range(1, d + 1):
		if d % i != 0:
			continue
		res = []
		f = False
		cur = y
		need = n
		while cur >= 1 and need > 0:
			res.append(cur)
			if cur == x:
				f = True
			need -= 1
			cur -= i
		cur = y
		while need > 0:
			cur += i
			res.append(cur)
			need -= 1
		res.sort()
		if need == 0 and f == True:
			if len(ans) == 0 or ans[-1] > res[-1]:
				ans = res
	print(' '.join(map(str, ans)))


TC = int(input())
for tc in range(TC):
	(N, X, Y) = map(int, input().split())
	delta = Y - X
	max_len = 1
	for i in range(N - 1, 0, -1):
		if delta % i == 0:
			max_len = i
			break
	d = delta // max_len
	item = X % d
	if item == 0:
		item += d
	max_item = item + d * (N - 1)
	if max_item < Y:
		item += Y - max_item
	for i in range(N):
		print(item, end=' ')
		item += d
	print()


for i in range(int(input())):
	(n, a, b) = map(int, input().split())
	start = -1
	d = -100000
	ma = 1000000000000.0
	for i in range(1, n + 1):
		for j in range(i + 1, n + 1):
			if (b - a) % (j - i) == 0:
				dd = (b - a) // (j - i)
				curr = a - dd * (i - 1)
				end = curr + (n - 1) * dd
				if ma > end and curr > 0:
					ma = end
					start = curr
					d = dd
	for i in range(n):
		print(start + d * i, end=' ')
	print()


for l in [*open(0)][1:]:
	(n, x, y) = map(int, l.split())
	p = []
	for i in range(1, n):
		if (y - x) % i == 0:
			s = (y - x) // i
			a = x % s
			if a == 0:
				a = s
			p.append((max(a + s * n - s, y), s))
	(a, b) = min(p)
	print(*range(a - b * n + b, a + 1, b))


t = int(input())
for hh in range(0, t):
	(n, x, y) = [int(x) for x in input().split()]
	diff = y - x
	mn = 100000000
	for i in range(1, 50):
		if mn != 100000000:
			break
		if diff % i == 0:
			cnt = diff // i
			ele_cnt = cnt + 1
			if ele_cnt <= n:
				low_cnt = (x - 1) // i
				tot_ele = ele_cnt + low_cnt
				if tot_ele >= n:
					mn = min(mn, y)
					diff_ans = i
				else:
					remm = n - tot_ele
					last_ele = y + i * remm
					mn = min(mn, last_ele)
					diff_ans = i
	li = []
	for i in range(x, y + 1, diff_ans):
		li.append(i)
	if len(li) < n:
		for i in range(x - diff_ans, 0, -diff_ans):
			li.append(i)
			if len(li) == n:
				break
	if len(li) < n:
		for i in range(y + diff_ans, mn + 1, diff_ans):
			li.append(i)
			if len(li) == n:
				break
	print(*li)


for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	i = 1
	f = y
	while (y - x) % i != 0 or (y - x) // i >= n:
		i += 1
	for j in range(n):
		if y <= 0:
			break
		print(y, end=' ')
		n -= 1
		y -= i
	for j in range(n):
		f += i
		print(f, end=' ')
	print()


from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
T = int(input())
for t in range(T):
	(n, x, y) = [int(s) for s in input().split()]
	FF = factors(abs(x - y))
	if x > y:
		(x, y) = (y, x)
	best = 10 ** 9
	ans = []
	for F in FF:
		if (y - x) // F >= n:
			continue
		else:
			tmp = [y]
			j = 1
			while len(tmp) < n and y - F * j > 0:
				tmp.append(y - F * j)
				j += 1
			j = 1
			while len(tmp) < n:
				tmp.append(y + F * j)
				j += 1
			if max(tmp) < best:
				best = max(tmp)
				ans = list(tmp)
	print(*ans)


import sys
import bisect
import math as mt
input = sys.stdin.readline
t = int(input())
mod = 10 ** 9 + 7
for _ in range(t):
	(n, x, y) = map(int, input().split())
	l = []
	for i in range(1, y - x + 1):
		cnt = 1
		d = {}
		d[y] = 0
		x1 = x
		ch = 0
		while cnt < n:
			x1 = x1 + i
			if x1 < y:
				cnt += 1
			elif x1 == y:
				ch = 1
				for j in range(x - i, 0, -i):
					cnt += 1
				if cnt < n:
					cnt = n
			else:
				cnt += 1
		if ch == 1:
			ind = i
			break
	i = x
	l.append(x)
	while i < y:
		i += ind
		l.append(i)
	i = x
	while len(l) < n and i > 0:
		i -= ind
		if i > 0:
			l.append(i)
	i = y
	while len(l) < n:
		i += ind
		l.append(i)
	print(*l)


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	for x in range(n - 1, 0, -1):
		if (b - a) % x == 0:
			break
	z = x - 1
	d = (b - a) // x
	if z + 2 == n:
		for i in range(n):
			print(a + i * d, end=' ')
		print()
	elif z + 2 < n:
		r = n - (z + 2)
		if (a - 1) // d >= r:
			a = a - d * r
			for i in range(n):
				print(a + i * d, end=' ')
			print()
		else:
			f = (a - 1) // d
			a = a - d * f
			for i in range(n):
				print(a + i * d, end=' ')
			print()
	else:
		r = n - 2
		if (a - 1) // d >= r:
			a = a - d * r
		else:
			f = (a - 1) // d
			a = a - d * f
		for i in range(n):
			print(a + d * i, end=' ')
		print()


T = int(input())
for _ in range(T):
	(n, x, y) = map(int, input().split())
	d = y - x
	if d == n - 1:
		for i in range(x, y + 1):
			print(i, end=' ')
		print()
	elif d > n - 1:
		if d % (n - 1) == 0:
			d = d // (n - 1)
			for i in range(n):
				print(d * i + x, end=' ')
			print()
		else:
			N = n - 2
			while d % N:
				N -= 1
			d = d // N
			m = 0
			for i in range(y, 0, -d):
				print(i, end=' ')
				m += 1
				if m == n:
					print()
					break
			if m < n:
				for i in range(y + d, y + d * (n - m + 1), d):
					print(i, end=' ')
				print()
	else:
		m = 0
		for i in range(y, 0, -1):
			print(i, end=' ')
			m += 1
			if m == n:
				print()
				break
		if m < n:
			for i in range(y + 1, y + n - m + 1):
				print(i)
			print()


def gt():
	return list(map(int, input().split()))
(t,) = gt()
while t:
	t -= 1
	(n, x, y) = gt()
	leng = abs(y - x)
	ans = 1
	for i in range(1, min(leng, n - 1) + 1):
		if leng % i == 0:
			ans = i
	seg = leng // ans
	start = x - (n - ans - 1) * seg
	if start < 0:
		start %= seg
	if start == 0:
		start = seg
	ar = [start + i * (leng // ans) for i in range(n)]
	print(*ar)


for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	h = y - x
	s = 1
	for j in range(2, n):
		if h % j == 0:
			s = j
	a = []
	p = (y - x) // s
	if s + 1 >= n:
		for j in range(x, y + 1, p):
			a.append(j)
	else:
		if x % p == 0:
			k = x // p - 1
		else:
			k = x // p
		l = n - s - 1
		z = min(l, k)
		for j in range(x - z * p, y + 1, p):
			a.append(j)
		u = n - z - s - 1
		while u > 0:
			a.append(y + p)
			y += p
			u -= 1
	print(*a)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	c = 0
	diff = y - x
	if diff % (n - 1) == 0:
		val = diff // (n - 1)
		ans = []
		ans.append(x)
		for i in range(n - 1):
			x = x + val
			ans.append(x)
		print(*ans)
	else:
		val = 0
		for i in range(n - 2, 0, -1):
			if diff % i == 0:
				val = i
				break
		d = n - 1 - val
		c = d
		ans = []
		cv = x
		s = diff // val
		for i in range(d):
			cv -= s
			if cv < 1:
				break
			else:
				ans.append(cv)
				c -= 1
		for i in range(val + 1):
			ans.append(x)
			x += s
		if c > 0:
			for i in range(c):
				ans.append(y + s)
				y = y + s
		print(*ans)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = y - x
	for i in range(1, y - x):
		if (y - x) % i == 0 and (y - x) // i + 1 <= n:
			d = i
			break
	a1 = x
	while a1 - d > 0 and a1 - d + d * (n - 1) >= y:
		a1 -= d
	terms = [str(a1 + d * i) for i in range(n)]
	print(' '.join(terms))


def small(a):
	po = []
	for i in range(1, a + 1):
		if a % i == 0:
			po.append(i)
	return po
for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	if n == 2:
		print(x, y)
	else:
		num = n
		diff = y - x
		(ap, fin_ap) = ([], [])
		po = small(diff)
		maxy = 300000000
		for elem in po:
			if y - elem * n > x:
				continue
			z = n
			t2 = y
			t3 = y
			while z:
				z -= 1
				if t2 > 0:
					ap.append(t2)
					t2 = t2 - elem
				else:
					t3 = t3 + elem
					ap.append(t3)
			if t3 + elem < maxy and x in ap:
				fin_ap = ap
				ap = []
				maxy = t3 + elem
			else:
				ap = []
		for x in fin_ap:
			print(x, end=' ')


def read(datatype=int):
	return datatype(input())

def readl(datatype=int):
	return list(map(datatype, input().split()))

def printl(data):
	string = ''
	for d in data:
		string += str(d) + ' '
	print(string)

def testcase():
	(n, x, y) = readl()
	(x, y) = (max(x, y), min(x, y))
	arr = [0 for _ in range(n)]
	best_diff = 1
	best_max = 10 ** 9
	best_start = 1
	for diff in range(1, x - y + 1):
		if (x - y) % diff == 0:
			alpha = (x - y) // diff
			if alpha >= n:
				continue
			elif alpha == n - 1:
				best_diff = diff
				best_start = y
				break
			else:
				left = (y - 1) // diff
				if alpha + left >= n:
					best_max = x
					best_diff = diff
					best_start = y - diff * (n - alpha - 1)
					break
				else:
					right = n - alpha - left
					curr_max = x + diff * right
					curr_start = y - diff * (n - alpha - right)
					if curr_max < best_max:
						best_diff = diff
						best_max = curr_max
						best_start = curr_start
	arr = [best_start]
	for _ in range(n - 1):
		arr.append(arr[-1] + best_diff)
	printl(arr)
	return
t = read()
for _ in range(t):
	testcase()


import sys
input = sys.stdin.readline
ins = lambda : input().rstrip()
ini = lambda : int(input().rstrip())
inm = lambda : map(int, input().rstrip().split())
inl = lambda : list(map(int, input().split()))
out = lambda x, s='\n': print(s.join(map(str, x)))
ans = []
t = ini()
for _ in range(t):
	(n, x, y) = inm()
	dif = y - x
	for i in range(1, dif + 1):
		if dif % i != 0:
			continue
		count = n - 1
		start = y
		ok = False
		while count > 0 and start > 0:
			start -= i
			count -= 1
			if start == x:
				ok = True
		start += i if start <= 0 else 0
		if ok:
			break
	numbers = [start + i * j for j in range(n)]
	ans.append(numbers)
for i in ans:
	print(*i)


for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	i = 1
	ad = []
	bd = []
	while i * i <= y - x:
		if (y - x) % i == 0:
			ad.append(i)
			if i * i != y - x:
				bd.append((y - x) // i)
		i += 1
	ds = ad + bd[::-1]
	best = (float('inf'), 0)
	for d in ds:
		l = (y - x) // d + 1
		if l > n:
			continue
		p = n - l
		while x - p * d <= 0:
			p -= 1
		best = min(best, (y + (n - l - p) * d, x - p * d))
	d = (best[0] - best[1]) // (n - 1)
	print(*list(range(best[1], best[0] + 1, d)))


for ik in range(int(input())):
	(n, mi, ma) = map(int, input().split())
	ans = (mi, ma - mi)
	mini = mi + (n - 1) * (ma - mi)
	f = 0
	for i in range(1, mi + 1):
		for j in range(1, n + 1):
			for k in range(1, 200):
				if i + (j - 1) * k == mi:
					t = (ma - i) // k
					t += 1
					if t <= n and (ma - i) % k == 0:
						if i + (n - 1) * k <= mini:
							ans = (i, k)
							mini = i + (n - 1) * k
	for i in range(n):
		print(ans[0] + i * ans[1], end=' ')
	print()


import sys
import math
import collections
import operator as op
from collections import deque
from math import gcd, inf, sqrt, pi, cos, sin, ceil, log2
from bisect import bisect_right, bisect_left
from functools import reduce
from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(2 ** 20)

def factorial(n):
	if n == 0:
		return 1
	return n * factorial(n - 1)

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom

def prime_factors(n):
	i = 2
	factors = []
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.append(i)
	if n > 1:
		factors.append(n)
	return list(factors)

def sumDigits(no):
	return 0 if no == 0 else int(no % 10) + sumDigits(int(no / 10))
MOD = 1000000007
PMOD = 998244353
N = 10 ** 5
T = 1
T = int(stdin.readline())
for _ in range(T):
	(n, x, y) = list(map(int, stdin.readline().rstrip().split()))
	diff = y - x
	for delta in range(1, y - x + 1):
		if diff % delta:
			continue
		if diff // delta + 1 > n:
			continue
		k = min((y - 1) // delta, n - 1)
		a0 = y - k * delta
		for i in range(n):
			print(a0 + i * delta, end=' ')
		print()
		break


def find(n, x, y, diff):
	arr = [x]
	while arr[-1] < y:
		arr.append(arr[-1] + diff)
	if arr[-1] != y:
		return False
	if len(arr) > n:
		return False
	min_val = arr[0]
	while len(arr) != n:
		if min_val - diff > 0:
			arr.append(min_val - diff)
			min_val -= diff
		else:
			break
	arr.sort()
	while len(arr) != n:
		arr.append(arr[-1] + diff)
	return arr

def solve(n, x, y, ans):
	for diff in range(1, 100):
		arr = find(n, x, y, diff)
		if arr:
			arr1 = []
			for i in arr:
				arr1.append(str(i))
			ans.append(arr1)
			return

def main():
	t = int(input())
	ans = []
	for i in range(t):
		(n, x, y) = map(int, input().split())
		solve(n, x, y, ans)
	for i in ans:
		print(' '.join(i))
main()


t = int(input())
for _ in range(t):
	line = input()
	pui = line.split()
	n = int(pui[0])
	x = int(pui[1])
	y = int(pui[2])
	dif = y - x
	i = int(dif / n)
	if i == 0:
		i = 1
	while True:
		if dif % i == 0:
			if dif / i <= n - 1:
				d = i
				break
		i += 1
	mem = 0
	num = y
	ans = list()
	ans.append(num)
	mem += 1
	while mem < n:
		num = num - d
		if num < 1:
			break
		ans.append(num)
		mem += 1
	num = y
	for i in range(n - mem):
		num = num + d
		ans.append(num)
	for i in ans:
		print(i, end=' ')
	print()


for q in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = {}
	d[x] = 1
	d[y] = 1
	c = 0
	tmp = y - x
	res = []
	for i in range(n - 1):
		for j in range(i + 1, n):
			a = [0] * n
			c += 1
			a[i] = x
			a[j] = y
			if tmp % (j - i) == 0:
				Y = tmp // (j - i)
				base = Y + a[i]
				for k in range(i + 1, n):
					if a[k] == 0:
						a[k] = base
						base += Y
					else:
						base += Y
				base = a[i] - Y
				flag = 0
				for k in range(i):
					if base <= 0:
						flag = 1
						break
					if a[k] == 0:
						a[k] = base
						base -= Y
					else:
						base -= Y
				if flag == 0:
					res.append(a)
	mi = float('inf')
	ind = -1
	for i in range(len(res)):
		if max(res[i]) < mi:
			mi = max(res[i])
			ind = i
	print(*res[ind])


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = y - x
	n -= 2
	out = [x]
	i = 1
	while i <= d:
		if d % i != 0 or d // i - 1 > n:
			i += 1
		else:
			while n > 0 and out[-1] + i != y:
				out.append(out[-1] + i)
				n -= 1
			if n > 0 and x - i > 0:
				n -= 1
				out.append(x - i)
			if n != 0 and out[-1] != x - i:
				out.append(y + i)
				n -= 1
				while n > 0:
					out.append(out[-1] + i)
					n -= 1
			elif n != 0 and out[-1] == x - i:
				while n > 0 and out[-1] - i > 0:
					out.append(out[-1] - i)
					n -= 1
				if n != 0:
					out.append(y + i)
					n -= 1
					while n > 0:
						out.append(out[-1] + i)
						n -= 1
			break
	out.append(y)
	print(*out)


import sys
read = lambda : sys.stdin.readline().strip()
from math import ceil
for _ in range(int(read())):
	(n, x, y) = map(int, read().split())
	low = ceil((y - x) / (n - 1))
	diff = None
	for i in range(low, y + 1):
		if (y - x) / i - (y - x) // i == 0:
			diff = i
			break
	a = None
	temp = y
	count = n
	while temp > 0 and count > 0:
		temp -= diff
		count -= 1
	a = temp + diff
	for i in range(n):
		print(a + i * diff, end=' ')
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	res = [10 ** 18]
	if n == 2:
		res = [x, y]
	else:
		for i in range(1, 51):
			tmp = []
			if (y - x) % i == 0 and (y - x) // i <= n - 1:
				tmp = [j for j in range(x, y + 1, i)]
				nn = n - len(tmp)
				if nn > 0:
					for j in range(x - i, 0, -i):
						tmp = [j] + tmp
						nn -= 1
						if nn == 0:
							break
				if nn > 0:
					for j in range(y + i, y + n * i, i):
						tmp.append(j)
						nn -= 1
						if nn == 0:
							break
				if res[-1] > tmp[-1]:
					res = tmp
	print(*res)


import sys
input = sys.stdin.buffer.readline

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

def prog():
	for _ in range(int(input())):
		(n, x, y) = map(int, input().split())
		pos = []
		for start in range(1, 51):
			for i in range(1, 51):
				if i + start > 50:
					break
				if (y - start) % i == 0 and y >= start and ((y - start) // i < n) and ((x - start) % i == 0) and (x >= start) and ((x - start) // i < n):
					pos.append([start, i])
		best_idx = 0
		most = 10 ** 9
		for i in range(len(pos)):
			if pos[i][0] + (n - 1) * pos[i][1] < most:
				best_idx = i
				most = pos[i][0] + (n - 1) * pos[i][1]
		output = []
		for i in range(n):
			output.append(str(pos[best_idx][0] + i * pos[best_idx][1]))
		print(' '.join(output))
prog()


t = int(input())
for j in range(t):
	(n, x, y) = input().split()
	n = int(n)
	x = int(x)
	y = int(y)
	d = y - x
	ind = 1
	g = 0
	t = n - 1
	while (y - x) % t:
		t = t - 1
	i = (y - x) // t
	x = max(x % i or i, y - (n - 1) * i)
	print(*range(x, x + n * i, i))


from sys import stdin

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

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

def linput():
	return list(map(int, stdin.readline().split()))
from collections import defaultdict
from math import factorial, sqrt

def factors(d):
	f = [1, d]
	for i in range(2, int(sqrt(d)) + 1):
		if d % i == 0:
			f.append(i)
			if i != d // i:
				f.append(d // i)
	return f
t = iinput()
while t:
	t -= 1
	(n, x, y) = linput()
	if n == 2:
		print(x, y)
	else:
		diff = y - x
		f = factors(diff)
		f.sort()
		req = n - 2
		arr = []
		for e in f:
			if diff % e == 0 and diff // e <= n - 1:
				arr = list(range(x, y + 1, e))
				temp = x - e
				while len(arr) < n and temp > 0:
					arr = [temp] + arr
					temp -= e
				while len(arr) < n:
					arr += [arr[-1] + e]
				break
		print(*arr)


import sys
from collections import defaultdict as dd
from collections import Counter as cc
from queue import Queue
import math
import itertools
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass
input = lambda : sys.stdin.buffer.readline().rstrip()
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		w = []
		e = y - x
		for i in range(1, e + 1):
			if e % i == 0:
				w.append(i)
		for i in w:
			if y - n * i + i > x and y - n * i + i > 0:
				continue
			if y - n * i + i <= x and y - n * i + i > 0:
				print(*[j for j in range(y, y - n * i, -i)])
				break
			elif y - n * i + i <= x and y - n * i + i <= 0:
				k = []
				for j in range(n):
					if y % i == 0:
						k.append(i + j * i)
					else:
						k.append(y % i + j * i)
				print(*k)
				break


def calc(n, x, y):
	(best_maximum, best_k) = (1000000001, 0)
	for m in range(1, n):
		k = (y - x) // m
		if m * k != y - x:
			continue
		start = y - k * (n - 1)
		delta = 0
		if start <= 0:
			delta = (k - start) // k
			start += delta * k
		if start > x:
			continue
		maximum = y + delta * k
		if maximum < best_maximum:
			best_maximum = maximum
			best_k = k
	assert best_k > 0
	res = []
	for i in range(n):
		res.append(best_maximum)
		best_maximum -= best_k
	return res

def get_ints():
	return [int(n) for n in input().split()]

def get_floats():
	return [float(n) for n in input().split()]

def seq2str(seq):
	return ' '.join((str(item) for item in seq))
zzz = get_ints()
assert len(zzz) == 1
t = zzz[0]
for i in range(t):
	zzz = get_ints()
	assert len(zzz) == 3
	(n, x, y) = (zzz[0], zzz[1], zzz[2])
	res = calc(n, x, y)
	print(seq2str(res))


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	for i in range(n - 1, 0, -1):
		if (y - x) % i == 0:
			d = (y - x) // i
			break
	z1 = x
	z = 0
	while z1 > 0:
		z = z1
		z1 -= d
	final = z + (n - 1) * d
	if final < y:
		final = y
	cd = (final - z) // (n - 1)
	for i in range(n):
		print(final, end=' ')
		final -= d


t = int(input())
for _ in range(t):
	hello = list(map(int, input().split()))
	n = hello[0]
	x = hello[1]
	y = hello[2]
	m = n - 1
	while m != 0:
		if (x - y) % m == 0:
			dif = (y - x) // m
			break
		m -= 1
	while True:
		if y - dif * (n - 1) < 1:
			y += dif
		else:
			break
	for i in range(n):
		print(y, end=' ')
		y -= dif
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	out = [1000000001]
	for i in range(1, 50):
		for j in range(1, 50):
			l = [i + f * j for f in range(n)]
			if x in l and y in l and (out[-1] > l[-1]):
				out = l
	print(*out)


for _ in range(int(input())):
	(n, a, b) = [int(c) for c in input().split()]
	finalmax = float('inf')
	finalpos = None
	finaldis = None
	for i in range(n):
		if a < i + 1:
			break
		for j in range(i + 1, n):
			if (b - a) % (j - i) != 0:
				continue
			dis = (b - a) // (j - i)
			maxval = b + (n - j - 1) * dis
			if maxval <= finalmax and maxval - (n - 1) * dis > 0:
				finaldis = dis
				finalmax = maxval
				finalpos = (i, j)
	ans = []
	for i in range(n):
		ans.append(finalmax)
		finalmax -= finaldis
	print(*ans)


t = int(input())
for i3 in range(t):
	(n, b, c) = [int(i) for i in input().split()]
	a = [b, c]
	n -= 1
	dem = 0
	for i in range(n, 0, -1):
		if (c - b) % i == 0:
			z = (c - b) // i
			t = b
			while t < c:
				t += z
				if t < c:
					a.append(t)
			t = b
			for i2 in range(n - i):
				t -= z
				if t > 0:
					dem += 1
					a.append(t)
				else:
					break
			if dem < n - i:
				t = c
				for i in range(n - i - dem):
					t += z
					a.append(t)
			break
	for i in a:
		print(i, end=' ')
	print()


def solve():
	(n, x, y) = map(int, input().split())
	maxx = float('inf')
	for i in range(1, 51):
		for j in range(1, 51):
			l = [i + k * j for k in range(n)]
			if x in l and y in l and (l[-1] < maxx):
				maxx = l[-1]
				ans = l
	print(*ans)
for _ in range(int(input())):
	solve()


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	d = 0
	q = 0
	for i in range(1, n):
		d = (y - x) / (n - i)
		q = int(d)
		if d == q:
			break
	for ber in range(n):
		if y - ber * q > 0:
			print(y - ber * q, end=' ')
		else:
			for car in range(1, n - ber + 1):
				print(y + car * q, end=' ')
			break
	print()


t_case = int(input())
for _ in range(t_case):
	(n, a, b) = map(int, input().split())
	flag = False
	all = []
	m = 10 ** 9
	for i in range(1, 51):
		for j in range(1, 51):
			l = [i + j * m for m in range(n)]
			if a in l and b in l:
				all.append(l)
				if max(l) < m:
					m = max(l)
	for i in all:
		if max(i) == m:
			for z in i:
				print(z, end=' ')
			print()
			break


import math
t = int(input())
while t > 0:
	(n, x, y) = [int(x) for x in input().split()]
	diff = y - x
	i = int(math.ceil(diff / (n - 1)))
	while diff % i != 0:
		i += 1
	tx = x
	ans = []
	while tx <= y:
		ans.append(tx)
		tx += i
		n -= 1
	tx = x - i
	while n > 0 and tx > 0:
		ans.append(tx)
		tx -= i
		n -= 1
	tx = y + i
	while n > 0:
		ans.append(tx)
		tx += i
		n -= 1
	for i in ans:
		print(i, end=' ')
	print()
	t -= 1


import sys

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

def in1():
	return int(input())
for _ in range(in1()):
	(n, x, y) = get_line()
	n1 = 1
	n2 = n
	t1 = y - x
	c = []
	while n2 != n1:
		if t1 % (n2 - n1) == 0:
			break
		else:
			n2 -= 1
	t2 = t1 // (n2 - 1)
	x1 = x
	y1 = y
	while x1 <= y1:
		c.append(x1)
		x1 += t2
	d = t1 // t2
	while x > 0 and d < n:
		d += 1
		c.append(x)
		x -= t2
	if d == n:
		print(*set(c))
	else:
		while d <= n:
			d += 1
			c.append(y)
			y += t2
		print(*set(c))


for i in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	min_n = 0
	min_k = 1000000000000000
	raz = 0
	for j in range(1, 110):
		for k in range(1, 110):
			if (x - j) % k == 0 and (y - j) % k == 0:
				if j + k * (n - 1) >= y and j <= x:
					if min_k > j + k * (n - 1):
						min_n = j
						min_k = j + k * (n - 1)
						raz = k
	for j in range(n):
		print(min_n + raz * j, end=' ')
	print()


t = int(input())
while t > 0:
	t -= 1
	[n, x, y] = list(map(int, input().split(' ')))
	d = 0
	for i in range(n, 1, -1):
		if (y - x) % (i - 1) == 0:
			d = (y - x) // (i - 1)
			n -= i
			break
	res = []
	a0 = x
	an = y
	while a0 <= an:
		res.append(a0)
		a0 += d
	a0 = x - d
	while n != 0 and a0 > 0:
		res.append(a0)
		a0 -= d
		n -= 1
	a0 = y + d
	while n != 0:
		res.append(a0)
		a0 += d
		n -= 1
	for i in res:
		print(i, end=' ')
	print('\n')


from math import sqrt

def check_if_possible(num):
	temp = n * num - num
	temp = y - temp
	if temp <= x:
		return True
	return False
for I in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	divisors = []
	for num in range(1, int(sqrt(diff)) + 2):
		if diff % num == 0:
			if num not in divisors:
				divisors.append(num)
			temp = diff // num
			if temp not in divisors:
				divisors.append(temp)
	divisors.sort()
	gap = -1
	for num in divisors:
		if check_if_possible(num):
			gap = num
			break
	startwith = y
	while startwith > 0 and n > 0:
		print(startwith, end=' ')
		startwith -= gap
		n -= 1
	for i in range(n):
		y += gap
		print(y, end=' ')
	print()


import math

def pd(n):
	i = 1
	l = [1]
	while i <= math.sqrt(n):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
		i = i + 1
	return l
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	l = pd(abs(x - y))
	l.sort()
	for i in l:
		if abs(x - y) // i < n:
			break
	ans = i
	l = []
	c = 0
	for i in range(x + ans, y + 1, ans):
		l.append(i)
		c += 1
	if c < n:
		for i in range(x, 0, -ans):
			if c == n:
				break
			l.append(i)
			c += 1
	if c < n:
		for i in range(y + ans, 100000000000, ans):
			if c == n:
				break
			l.append(i)
			c += 1
	print(*l)


def read_int():
	return int(input().strip())

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

def read_string():
	return input()

def read_strings():
	return input().strip().split()

def swap(x, y):
	return (y, x)

def divs(num):
	divisors = []
	for i in range(num):
		if num % (i + 1) == 0:
			divisors.append(i + 1)
	return divisors

def check(div, x, y, n):
	solution = []
	i = 0
	while True:
		solution.append(y - i * div)
		i += 1
		if i == n or y - i * div < 1:
			break
	n -= i
	for j in range(n):
		solution.append(y + (j + 1) * div)
	mini = min(solution)
	if mini > x and mini - x > div:
		return None
	if mini > x and n == 0:
		return None
	return solution

def solve():
	(n, x, y) = read_ints()
	if n == 2:
		print(f'{x} {y}')
		return
	if x > y:
		(x, y) = swap(x, y)
	divisors = divs(y - x)
	for div in divisors:
		solution = check(div, x, y, n)
		if solution:
			print(*solution)
			return

def read_input():
	t = read_int()
	for _ in range(t):
		solve()
read_input()


t = int(input())

def get_factors(n):
	factors = []
	for i in range(1, n + 1):
		if n % i == 0:
			factors.append(i)
	return factors
for _ in range(t):
	(n, x, y) = map(int, input().split())
	delta = y - x
	factors = get_factors(delta)
	smallest_factor = delta
	for i in factors:
		if delta / i + 1 <= n:
			smallest_factor = i
			break
	for y_idx in range(n - 1, -1, -1):
		left_most = y - y_idx * smallest_factor
		if left_most >= 1:
			right_most = y + (n - 1 - y_idx) * smallest_factor
			print(*list(range(left_most, right_most + 1, smallest_factor)))
			break


import math
t = int(input())

def solve():
	(n, x, y) = map(int, input().split())
	diff = y - x
	arr = [0] * n
	if n == 2:
		print(str(x) + ' ' + str(y))
		return
	else:
		fact = []
		for i in range(1, int(diff ** 0.5) + 1):
			if diff % i == 0:
				fact.append(i)
				fact.append(int(diff / i))
		for i in fact:
			if y - (n - 1) * i <= x and y - (n - 1) * i > 0:
				arr[-1] = y
				for j in reversed(range(0, n - 1)):
					arr[j] = arr[j + 1] - i
				break
		else:
			fact.sort()
			for i in fact:
				if y - (n - 1) * i <= 0:
					shift = 1 - (y - (n - 1) * i)
					f = int(math.ceil(shift / i)) * i
					arr[0] = y - (n - 1) * i + f
					for j in range(1, n):
						arr[j] = arr[j - 1] + i
					break
	string = ' '.join(map(str, arr))
	print(string)
for i in range(t):
	solve()


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	if (y - x) % (n - 1) == 0:
		for i in range(n):
			print(x + i * ((y - x) // (n - 1)), end=' ')
	else:
		ans = 10 ** 9 + 1
		d = y - x
		for i in range(1, d + 1):
			if d % i == 0:
				if d // i + 1 <= n:
					if y > (n - 1) * i:
						if y < ans:
							ans = y
							ansmin = y - (n - 1) * i
							ansi = i
					elif y % i != 0:
						if y % i + (n - 1) * i < ans:
							ans = y % i + (n - 1) * i
							ansmin = y % i
							ansi = i
					elif i + (n - 1) * i < ans:
						ans = i + (n - 1) * i
						ansmin = i
						ansi = i
		for i in range(n):
			print(ansmin + i * ansi, end=' ')
	print('')


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	diff = y - x
	arr = []
	g = 0
	for diffi in range(1, diff + 1):
		starte = 1
		ini = starte
		while starte <= x:
			arr = []
			ini = starte
			while len(arr) < n:
				arr.append(ini)
				ini += diffi
			if x in arr and y in arr:
				g = 1
				break
			starte += 1
		if g == 1:
			break
	print(*arr)


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	D = y - x
	d = 1
	for i in range(n - 1, 0, -1):
		if D % i == 0:
			d = D // i
			break
	ans = []
	t = x
	while t <= y:
		ans.append(t)
		t += d
	if len(ans) < n:
		u = x - d
		v = y + d
		while len(ans) < n and u > 0:
			ans.append(u)
			u -= d
		while len(ans) < n:
			ans.append(v)
			v += d
	for ele in ans:
		print(ele, end=' ')
	print()


from math import *
t = int(input())
while t:
	t = t - 1
	(n, x, y) = map(int, input().split())
	diff = y - x
	z = 1
	while z <= diff:
		if diff % z == 0 and diff // z + 1 <= n:
			break
		z += 1
	flag = 0
	yy = y
	while n:
		if flag == 0:
			print(y, end=' ')
			y = y - z
			if y <= 0:
				y = yy + z
				flag = 1
		else:
			print(y, end=' ')
			y = y + z
		n -= 1
	print()


t = int(input())
for ex in range(t):
	(n, x, y) = [int(i) for i in input().split()]
	c = n - 1
	d = y - x
	while c > 0:
		if d % c == 0:
			step = d // c
			break
		else:
			c -= 1
	if c == 0:
		step = d
	p = max(n - 1 - c, 0)
	mi = x - step * min(p, x // step - int(x % step == 0))
	a = list()
	for i in range(n):
		a.append(mi + step * i)
	print(*a)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	result = None
	distance = y - x
	differences = [i for i in range(1, distance + 1) if distance % i == 0]
	for difference in differences:
		array = [y]
		before = True
		next = y - difference
		for i in range(1, n):
			if before:
				array.insert(0, next)
				next -= difference
				if next <= 0:
					next = y + difference
					before = False
			else:
				array.append(next)
				next += difference
		if x in array:
			if result == None:
				result = array
			elif array[-1] < result[-1]:
				result = array
	print(*result)


from collections import defaultdict as dd
import sys
input = sys.stdin.readline
t = int(input())
while t:
	(n, x, y) = list(map(int, input().split()))
	dif = y - x
	for i in range(n - 1, -1, -1):
		if dif % i == 0:
			ind = i
			break
	diff = dif // ind
	arr = [x]
	cou = 1
	curr = x
	while curr != y:
		curr += diff
		arr.append(curr)
		cou += 1
	left = n - cou
	curr = x
	while left and curr - diff > 0:
		curr -= diff
		arr.append(curr)
		left -= 1
	curr = y
	while left:
		curr += diff
		arr.append(curr)
		left -= 1
	print(*arr)
	t -= 1


def go(a, d, n):
	res = [a]
	for i in range(1, n):
		res.append(res[i - 1] + d)
	return res
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	final = []
	best = 10000000000
	for i in range(1, 51):
		for cd in range(1, 51):
			arr = go(i, cd, n)
			boolx = False
			booly = False
			for el in arr:
				if el == x:
					boolx = True
				if el == y:
					booly = True
			if boolx == 1 and booly == 1 and (arr[-1] < best):
				best = arr[-1]
				final = arr
	print(*final)


t = int(input())
for i in range(t):
	ans = []
	(n, x, y) = map(int, input().split())
	raz = y - x
	for j in range(1, raz + 1):
		if raz % j == 0 and raz // j <= n - 1:
			per = n - raz // j
			fer = max(x - x // j * j, 1)
			ans = [a for a in range(y, fer - 1, -j)]
			if len(ans) > n:
				ans = ans[0:n]
			if len(ans) < n:
				ans = [y + j * a for a in range(1, n - len(ans) + 1)] + ans
			for i in ans:
				print(i, end=' ')
			print()
			break


def ceil(a, b):
	if a % b == 0:
		return a // b
	return a // b + 1
t = int(input())
for _ in range(t):
	(n, x, y) = list(map(int, input().strip().split()))
	ans = [x, y]
	a = y - x
	b = ceil(a, n - 1)
	for i in range(b, a + 1):
		if a % i == 0:
			mid = a // i + 1
			for j in range(mid - 2):
				ans.append(x + i * (j + 1))
			left = (x - 1) // i
			if left + mid >= n:
				for j in range(n - mid):
					ans.append(x - i * (j + 1))
			else:
				for j in range(left):
					ans.append(x - i * (j + 1))
				for j in range(n - left - mid):
					ans.append(y + i * (j + 1))
			break
	print(' '.join(map(str, ans)))


def Search(n, low, high):
	arr = []
	limit = 10 ** 9 + 1
	for piv in range(low + 1, high + 1):
		(d1, d2) = (piv - low, high - piv)
		if d2 % d1 == 0 and (high - low) // d1 <= n - 1:
			break
	piv -= low
	for num in range(low, high + 1, piv):
		if not n:
			break
		arr.append(num)
		n -= 1
	for num in range(low - piv, 0, -piv):
		if not n:
			break
		arr.append(num)
		n -= 1
	for num in range(high + piv, limit, piv):
		if not n:
			break
		arr.append(num)
		n -= 1
	return arr
t = int(input())
for _ in range(t):
	(n, x, y) = tuple(map(int, input().split()))
	print(*Search(n, x, y))


T = int(input())
for _ in range(0, T):
	(n, x, y) = map(int, input().split())
	ct = 2
	diff = y - x
	for i in range(1, 51):
		if (y - x) % i == 0 and (y - x) // i + 1 <= n:
			ct = (y - x) // i + 1
			diff = i
			break
	if ct < n:
		t1 = x // diff
		if x % diff == 0:
			t1 -= 1
		t1 = max(t1, 0)
		if t1 + ct >= n:
			d = n - ct
			x -= d * diff
		else:
			while x > 0:
				x -= diff
			x += diff
			d = n - ct - t1
			while d > 0:
				y += diff
				d -= 1
	ans = []
	for i in range(x, y + 1, diff):
		ans.append(i)
	print(*ans)


from math import *
from bisect import *
from collections import *
from decimal import *

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

def st():
	return input().rstrip('\n')

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

def ma():
	return map(int, input().split())
t = inp()
while t:
	t -= 1
	(n, x, y) = ma()
	res = []
	for i in range(n - 1):
		for j in range(i + 1, n):
			di = j - i
			bfl = 0
			if (y - x) % di == 0:
				com = (y - x) // di
				if i == 0:
					lef = x
				else:
					lef = x - i * com
				if lef <= 0:
					continue
				re = lef + (n - 1) * com
				res.append([re, com])
	res.sort()
	print(res[0][0], end=' ')
	op = res[0][1]
	x = res[0][0]
	for i in range(n - 1):
		print(x - op, end=' ')
		op += res[0][1]
	print()


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split(' '))
	if n == 2:
		print(x, y)
	else:
		arr = [x, y]
		diff = y - x
		between = n - 2 + 1
		while between >= 1:
			if diff % between == 0:
				interval = diff // between
				break
			between -= 1
		for i in range(1, between):
			arr.append(x + interval * i)
		leftover = n - between - 1
		for i in range(1, leftover + 1):
			new = x - interval * i
			if new > 0:
				arr.append(x - interval * i)
				leftover -= 1
			else:
				break
		for i in range(1, leftover + 1):
			arr.append(y + interval * i)
		print(*arr)


t = int(input())
while t > 0:
	(n, a, b) = [int(x) for x in input().split()]
	temp = b - a
	need = n - 1
	ans = 0
	for i in range(1, temp + 1):
		if temp % i == 0 and temp // i <= need:
			ans = max(ans, temp // i)
	part = temp // ans
	out = [a, b]
	k = a
	for i in range(ans - 1):
		out.append(k + part)
		k = k + part
	k = a
	while len(out) < n and k - part > 0:
		out.append(k - part)
		k = k - part
	k = b
	while len(out) < n:
		out.append(k + part)
		k = k + part
	print(*out)
	t -= 1


from math import inf
t = int(input())
for _ in range(t):
	cur_min = inf
	cur_best = None
	(n, x, y) = map(int, input().split())
	delta = y - x
	for i in range(n):
		for j in range(i + 1, n):
			idelta = j - i
			if delta % idelta != 0:
				continue
			el_delta = delta // idelta
			first_el = x - el_delta * i
			if first_el <= 0:
				continue
			last_el = x + el_delta * (n - i - 1)
			if last_el < cur_min:
				cur_min = last_el
				cur_best = [first_el + el_delta * v for v in range(n)]
	print(*cur_best)


from sys import stdin
tt = int(stdin.readline())
for loop in range(tt):
	(n, x, y) = map(int, stdin.readline().split())
	nmax = float('inf')
	ans = []
	for f in range(1, 51):
		for s in range(1, 51):
			tans = [s + f * i for i in range(n)]
			if x in tans and y in tans and (nmax > tans[-1]):
				nmax = tans[-1]
				ans = tans
	print(*ans)


def main():
	(n, x, y) = map(int, input().split())
	d = y - x
	(diff, i) = (0, 1)
	while True:
		if d % i == 0 and d // i < n:
			diff = i
			break
		i += 1
	while y - diff * n + diff <= 0:
		y += diff
	for i in range(1, n + 1):
		print(y, end=' ')
		y -= diff
	print('')
for _ in range(int(input())):
	main()


import math
t = int(input())
for _ in range(t):
	(n, x, y) = list(map(int, input().split()))
	for i in range(math.ceil((y - x) / (n - 1)), y - x + 1):
		if (y - x) % i == 0:
			print(*list(range(y - i * min(n - 1, math.ceil(y / i) - 1), y - i * min(n - 1, math.ceil(y / i) - 1) + i * (n - 1) + 1, i)))
			break


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	n -= 2
	dif = y - x
	c = 1
	while dif % c != 0 or n < dif // c - 1:
		c += 1
	res = [x]
	prev = x + c
	while prev != y:
		res.append(prev)
		prev += c
	res.append(y)
	prev = x - c
	while n + 2 != len(res) and prev > 0:
		res.append(prev)
		prev -= c
	prev = y + c
	while n + 2 != len(res):
		res.append(prev)
		prev += c
	print(' '.join(map(str, res)))


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	h = y - x
	for i in range(n - 1, 0, -1):
		if h % i == 0:
			d = h // i
			break
	ans = set()
	curn = y
	while curn > 0 and n > 0:
		ans.add(curn)
		curn -= d
		n -= 1
	for i in range(n):
		y += d
		ans.add(y)
	print(*ans)


from math import gcd
T = int(input())
for t in range(T):
	(n, x, y) = [int(x) for x in input().split()]
	if n == 2:
		print(x, y)
	else:
		dist = abs(x - y)
		for i in range(n - 1, 0, -1):
			(m, d) = divmod(dist, i)
			if d == 0:
				break
		inside = dist // m + 1
		total = inside
		lefttotal = abs(min([x, y]) - 1) // m
		leftmost = min([x, y]) - m * min([lefttotal, n - inside])
		p = range(leftmost, leftmost + m * (n - 1) + 1, m)
		print(*p)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	nn = n
	t = y - x
	mx = 1
	for i in range(1, n):
		if t % i == 0:
			mx = i
	ans = []
	for i in range(mx + 1):
		ans.append(x + t * i / mx)
	n = n - mx - 1
	d = t / mx
	now = x - d
	while n > 0 and now > 0:
		ans.append(now)
		now = now - d
		n = n - 1
	now = y + d
	while n > 0 and now > 0:
		ans.append(now)
		now = now + d
		n = n - 1
	for i in range(nn):
		print(int(ans[i]))


def req(n):
	l = [1]
	for i in range(2, n):
		if n % i == 0:
			l.append(i)
	return l
for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	final = [x, y]
	n -= 2
	if n == 0:
		for i in final:
			print(i, end=' ')
		print()
	else:
		f = req(y - x)
		diff = 0
		for i in f:
			num = (y - x) // i
			num -= 1
			if num <= n:
				diff = i
				break
		if diff == 0:
			diff = y - x
		anyy = diff + x
		while anyy < y and n > 0:
			final.append(anyy)
			anyy += diff
			n -= 1
		anyy = x - diff
		while anyy > 0 and n > 0:
			final.append(anyy)
			anyy -= diff
			n -= 1
		anyy = y + diff
		while n > 0:
			final.append(anyy)
			anyy += diff
			n -= 1
		for i in final:
			print(i, end=' ')
		print()


for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	d = n - 1
	while d > 0 and diff % d != 0:
		d = d - 1
	p = diff // d
	k = n
	num = y
	arr = []
	while k > 0 and num > 0:
		arr.append(num)
		num = num - p
		k = k - 1
	num = y
	while k > 0:
		num = num + p
		arr.append(num)
		k = k - 1
	print(*arr)


from audioop import reverse

def main():

	def enum_divisors(n):
		divs = []
		for i in range(1, n + 1):
			if i * i > n:
				break
			if n % i == 0:
				divs.append(i)
				if n // i != i:
					divs.append(n // i)
		return divs
	T = int(input())
	for _ in range(T):
		(n, x, y) = (int(i) for i in input().split())
		diff = y - x
		divs = enum_divisors(diff)
		divs.sort(reverse=True)
		ans = []
		ans_max = 10 ** 18
		for d in divs:
			A = [y]
			v = y
			while len(A) < n and 0 < v - d:
				v -= d
				A.append(v)
			v = y
			while len(A) < n:
				v += d
				A.append(v)
			maxA = max(A)
			A.sort()
			if x not in A or any((A[i + 1] - A[i] != d for i in range(len(A) - 1))):
				continue
			if len(A) == n and maxA < ans_max:
				ans = A
				ans_max = maxA
		print(*ans)
main()


import math
from decimal import Decimal
import heapq
import copy
import heapq
from collections import deque
from collections import defaultdict
MOD = 1000000007

def na():
	n = int(input())
	b = [int(x) for x in input().split()]
	return (n, b)

def nab():
	n = int(input())
	b = [int(x) for x in input().split()]
	c = [int(x) for x in input().split()]
	return (n, b, c)

def dv():
	(n, m) = map(int, input().split())
	return (n, m)

def da():
	(n, m) = map(int, input().split())
	a = list(map(int, input().split()))
	return (n, m, a)

def dva():
	(n, m) = map(int, input().split())
	a = [int(x) for x in input().split()]
	b = [int(x) for x in input().split()]
	return (n, m, b)

def eratosthenes(n):
	sieve = list(range(n + 1))
	for i in sieve:
		if i > 1:
			for j in range(i + i, len(sieve), i):
				sieve[j] = 0
	return sorted(set(sieve))

def lol(lst, k):
	k = k % len(lst)
	ret = [0] * len(lst)
	for i in range(len(lst)):
		if i + k < len(lst) and i + k >= 0:
			ret[i] = lst[i + k]
		if i + k >= len(lst):
			ret[i] = lst[i + k - len(lst)]
		if i + k < 0:
			ret[i] = lst[i + k + len(lst)]
	return ret

def nm():
	n = int(input())
	b = [int(x) for x in input().split()]
	m = int(input())
	c = [int(x) for x in input().split()]
	return (n, b, m, c)

def dvs():
	n = int(input())
	m = int(input())
	return (n, m)

def fact(n):
	tc = []
	ans = {}
	d = 2
	while d * d <= n:
		if n % d == 0:
			tc.append(d)
			n //= d
		else:
			d += 1
	if n > 1:
		tc.append(n)
	for i in tc:
		ans[i] = ans.get(i, 0) + 1
	return ans

def to_zero(n, s):
	lst = s[0]
	ans = []
	for i in range(n):
		if lst == s[i]:
			continue
		elif lst == '0':
			lst = '1'
			ans.append(i)
		else:
			lst = '0'
			ans.append(i)
	if lst == '1':
		ans.append(n)
	return ans
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	a = []
	mx = 99999999999999999999999999999999999999999999
	for i in range(1, 51):
		st = i
		f = False
		for j in range(1, 51):
			tec = []
			d = j
			for k in range(n):
				tec.append(st + d * k)
			if x in tec and y in tec and (tec[-1] < mx):
				a = tec
				mx = tec[-1]
	print(*a)


t = int(input())
while t > 0:
	(n, x, y) = map(int, input().split())
	diff = y - x
	arr1 = list()
	arr2 = list()
	arr3 = list()
	arr = [] * n
	for i in range(1, diff + 1):
		if diff % i == 0:
			arr1.append(i)
	arr1.sort(reverse=True)
	for j in range(len(arr1)):
		if arr1[j] > n - 1:
			continue
		elif arr1[j] <= n - 1:
			arr2 = arr1[j:]
			break
	a = int(diff / arr2[0])
	for b in reversed(range(n)):
		if y - a * b > 0:
			arr.insert(0, y - a * b)
			break
	for m in range(n):
		arr3.append(arr[0] + a * m)
	print(*arr3)
	t -= 1


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	x1 = x
	if n == 2:
		print(x, y)
	else:
		arr = []
		diff = y - x
		div = n - 1
		while diff % div != 0:
			div -= 1
		num = div + 1
		d = diff // div
		while x <= y:
			arr.append(x)
			x += d
		if num == n:
			print(*arr)
		else:
			x1 = x1 - d
			while num < n and x1 > 0:
				arr.append(x1)
				x1 -= d
				num += 1
			while num < n:
				arr.append(x)
				x += d
				num += 1
			print(*arr)


for _ in range(int(input())):
	(n, x, y) = [int(q) for q in input().split()]
	if n == 2:
		print(x, y)
		continue
	mini = float('inf')
	for start in range(1, x + 1):
		for d in range(1, y - x + 1):
			arr = [start + i * d for i in range(n)]
			if x in arr and y in arr:
				if arr[-1] < mini:
					mini = min(mini, arr[-1])
					final = arr
	print(' '.join((str(x) for x in final)))


t = int(input())
for _ in range(t):
	m = 0
	(n, x, y) = list(map(int, input().split()))
	(x, y) = (max(x, y), min(x, y))
	for i in range(1, n):
		if (x - y) % (n - i) == 0:
			m = (x - y) // (n - i)
			break
	if m == 0:
		print('problem')
	else:
		h = x - (n - 1) * m
		if h > 0:
			for i in range(1, n + 1):
				print(h + (i - 1) * m, end=' ')
		else:
			for i in range(n + 1):
				g = h + (i - 1) * m
				if g > 0:
					break
			for i in range(1, n + 1):
				print(g + (i - 1) * m, end=' ')
		print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	k = n - 1
	while (y - x) % k != 0:
		k -= 1
	m = (y - x) // k
	print(''.join([f'{x + r * m} ' for r in range(k + 1)]), end='')
	n -= k + 1
	if n and x - m > 0:
		print(''.join([f'{x - (r + 1) * m} ' for r in range(min(x // m - (1 if x % m == 0 else 0), n))]), end='')
		n -= min(n, x // m - (1 if x % m == 0 else 0))
	if n:
		print(''.join([f'{y + (r + 1) * m} ' for r in range(n)]), end='')
	print()


from sys import stdin, stdout
import math, sys, heapq
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import random
import bisect as bi

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

	def I():
		return int(input())

	def In():
		return map(int, input().split())
else:

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

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

def dict(a):
	d = {}
	for x in a:
		if d.get(x, -1) != -1:
			d[x] += 1
		else:
			d[x] = 1
	return d

def find_gt(a, x):
	i = bi.bisect_left(a, x)
	if i != len(a):
		return i
	else:
		return -1

def solve(a, b, x, y, n):
	temp = min(b - y, n)
	b -= temp
	n -= temp
	temp = min(a - x, n)
	a -= temp
	n -= temp
	return a * b

def main():
	try:
		(n, x, y) = In()
		temp = y - x
		i = 1
		an = 1
		for i in range(1, n):
			if temp >= i:
				if temp % i == 0:
					an = i
			else:
				break
		temp //= an
		ans = [x, y]
		(t, z) = (x, y)
		while n - 2 > 0:
			if y - temp > t:
				y -= temp
				ans.append(y)
			elif x - temp > 0:
				x -= temp
				ans.append(x)
			else:
				z += temp
				ans.append(z)
			n -= 1
		ans.sort()
		print(*ans)
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(I()):
	main()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	res = []
	for i in range(1, y + 1):
		for j in range(y + 1):
			(a, b, c) = ([], False, False)
			for k in range(n):
				a.append(i + j * k)
				if a[-1] == x:
					b = True
				if a[-1] == y:
					c = True
			if b and c:
				res.append(a)
	res.sort(key=lambda x: x[-1])
	print(*res[0])


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter
from itertools import combinations as comb
from itertools import permutations as permutate
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
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))
from types import GeneratorType

def iterative(f, stack=[]):

	def wrapped_func(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		to = f(*args, **kwargs)
		while True:
			if type(to) is GeneratorType:
				stack.append(to)
				to = next(to)
				continue
			stack.pop()
			if not stack:
				break
			to = stack[-1].send(to)
		return to
	return wrapped_func
mod = 1000000007

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

def integer():
	return int(inp())

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 zerolist(n):
	return [0] * n

def nextline():
	out('\n')

def testcase(t):
	for p in range(t):
		solve()

def printlist(a):
	for p in range(0, len(a)):
		out(str(a[p]) + ' ')
from functools import reduce

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

def solve():
	(n, a, b) = list(map(int, input().split(' ')))
	c = b - a
	d = 0
	flag = -1
	x1 = 0
	while flag != 1:
		for i in range(n - 1, 0, -1):
			for j in range(0, i):
				if c % (i - j) == 0:
					d = c // (i - j)
					x1 = b - i * d
					if x1 > 0:
						flag = 1
						break
					d = 0
			if d != 0:
				break
	for i in range(n):
		print(x1 + i * d, end=' ')
	print()
testcase(int(inp()))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = []
	mini = 10 ** 18
	for start in range(1, 51):
		for d in range(1, 51):
			a = [start + j * d for j in range(n)]
			if x in a and y in a:
				if a[-1] < mini:
					mini = a[-1]
					ans = a
	print(*ans)


import math
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		arr = []
		for i in range(1, 51):
			s = set()
			s.add(y)
			counter = 1
			ele = y
			eke = y
			while counter < n and ele > 0:
				ele -= i
				if ele <= 0:
					break
				s.add(ele)
				counter += 1
			while counter < n:
				eke += i
				s.add(eke)
				counter += 1
			if x in s and y in s:
				arr.append(s)
		mini = math.inf
		ans = set()
		for ele in arr:
			top = max(ele)
			if top < mini:
				mini = top
				ans = ele
		ans = sorted(ans)
		print(*ans)


import sys, math
import io, os
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter

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

def mdata():
	return list(map(int, data().split()))

def outl(var):
	sys.stdout.write(' '.join(map(str, var)) + '\n')

def out(var):
	sys.stdout.write(str(var) + '\n')
from decimal import Decimal
mod = int(1000000000.0) + 7
INF = 2 ** 32
for t in range(int(data())):
	(n, x, y) = mdata()
	m = INF
	ind = 0
	for i in range(1, y - x + 1):
		if (y - x) % i == 0 and (y - x) // i + 1 <= n:
			k = 0
			if y % i:
				k = 1
			if m > y + max(0, n - y // i - k) * i:
				m = y + max(0, n - y // i - k) * i
				ind = i
	ans = []
	for i in range(n):
		ans.append(m)
		m -= ind
	outl(ans[::-1])


t = int(input())
for _ in range(t):
	(n, x, y) = (int(x) for x in input().split())
	diff = y - x
	if diff == 0:
		print(' '.join([str(x)] * n))
		continue
	cur = min(diff, n - 1)
	while cur != 1:
		if diff % cur == 0:
			break
		cur -= 1
	ap = int(diff / cur)
	before = int(min(x // ap, n - 1 - cur))
	init = x - before * ap
	if init == 0:
		init += ap
	print(' '.join([str(init + x * ap) for x in range(n)]))


import copy
T = int(input())
for _ in range(T):
	(n, x, y) = map(int, input().split())
	answer = []
	for i in range(y - x, 0, -1):
		if (x - y) % i == 0:
			ok = False
			cnt = 0
			temp = []
			for j in range(n):
				check = y - i * j
				if check == x:
					ok = True
				if check <= 0:
					check = y + i * (j - cnt + 1)
				else:
					cnt += 1
				temp.append(check)
			if ok:
				answer = copy.copy(temp)
	print(*answer)


import collections

def solve():
	(n, x, y) = map(int, input().split())
	t = n
	l = collections.deque([])
	d = y - x
	while n > 1:
		n -= 1
		if d % n == 0:
			break
	a = d // n
	for i in range(x, y + 1, a):
		l.append(i)
	while l[0] - a > 0 and len(l) < t:
		l.appendleft(l[0] - a)
	while len(l) < t:
		l.append(l[-1] + a)
	return l
for __ in range(int(input())):
	for ele in solve():
		print(ele, end=' ')
	print()


for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	my_list = list()
	count = 0
	for elem in range(1, y - x + 1):
		if (y - x) % elem == 0:
			if (y - x) // elem <= n - 1:
				count = elem
				break
	number_of_elem = n
	help_elem = y
	while number_of_elem > 0:
		my_list.append(help_elem)
		help_elem -= count
		number_of_elem -= 1
		if help_elem <= 0:
			break
	if number_of_elem != 0:
		help_elem = y + count
		while number_of_elem > 0:
			my_list.append(help_elem)
			help_elem += count
			number_of_elem -= 1
	for elem in my_list:
		print(elem, end=' ')
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	p = y - x
	diff = -1
	num = 0
	for i in range(n - 1, -1, -1):
		if p % i == 0:
			diff = p // i
			num = i - 1
			break
	if diff == -1:
		diff = y - x
	n -= 2
	n -= num
	arr = []
	for i in range(x, y + 1, diff):
		arr.append(i)
	i = x
	while n > 0 and i > 0:
		i = i - diff
		if i > 0:
			arr.append(i)
			n -= 1
	i = y
	while n > 0:
		i += diff
		arr.append(i)
		n -= 1
	print(*arr)


from math import ceil
t = int(input())
for _ in range(t):
	(n, smol, beeg) = map(int, input().split())
	if beeg - smol == n - 1:
		for i in range(smol, beeg + 1):
			print(i, end=' ')
		print()
	elif beeg - smol > n - 1:
		ni = n - 1
		while (beeg - smol) % ni != 0:
			ni -= 1
		diff = (beeg - smol) // ni
		t = 0
		for i in range(min(n, ceil(beeg / diff))):
			t += 1
			print(beeg - diff * i, end=' ')
		while t < n:
			beeg += diff
			t += 1
			print(beeg, end=' ')
		print()
	else:
		t = 0
		while t < n and beeg - t > 0:
			print(beeg - t, end=' ')
			t += 1
		while t < n:
			beeg += 1
			t += 1
			print(beeg, end=' ')
		print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	tn = n
	ty = y
	c = 0
	tx = x
	while (y - x) % (tn - 1) != 0:
		tn -= 1
		c += 1
	d = (y - x) // (tn - 1)
	arr = [x]
	while c:
		if x - d <= 0:
			break
		c -= 1
		arr.append(x - d)
		x -= d
	arr.append(y)
	while len(arr) != n:
		if y - d in arr:
			break
		arr.append(y - d)
		y -= d
	while len(arr) != n:
		arr.append(ty + d)
		ty += d
	print(*arr)


import sys
input = sys.stdin.readline
t = int(input())
res = []
for _ in range(t):
	(n, x, y) = (int(i) for i in input().split())
	min_res = 1000000000
	min_step = -1
	for step in range(1, y - x + 1):
		if (y - x) % step:
			continue
		(num, steps) = (y, n - 1)
		while num > step and steps > 0:
			num -= step
			steps -= 1
		if steps == 0:
			if num <= x and y < min_res:
				min_res = y
				min_step = step
			continue
		num = y
		while steps > 0:
			num += step
			steps -= 1
		if num < min_res:
			min_res = num
			min_step = step
	res.append(list(range(min_res - min_step * (n - 1), min_res + 1, min_step)))
print('\n'.join((' '.join((str(i) for i in local_res)) for local_res in res)))


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	diff = y - x
	between = 0
	for q in range(1, n):
		if diff % q == 0:
			between = q
	d = diff // between
	rem = n - between - 1
	start = x - rem * d
	while start <= 0:
		start += d
	for i in range(n):
		print(start + i * d, end=' ')
	print()


t = int(input())
tasks = []
for i in range(t):
	tasks.append(list(map(int, input().split())))
for i in range(t):
	(n, x, y) = tasks[i]
	if n == 2:
		print(x, y)
	else:
		dividers = [j for j in range(1, y - x + 1) if (y - x) % j == 0]
		j = 0
		while (y - x) // dividers[j] - 1 > n - 2:
			j += 1
		step = dividers[j]
		answer = []
		z = x
		while z <= y:
			answer.append(z)
			n -= 1
			z += step
		z = x - step
		while z > 0 and n > 0:
			answer.append(z)
			n -= 1
			z -= step
		z = y + step
		while n > 0:
			answer.append(z)
			n -= 1
			z += step
		print(' '.join(map(str, answer)))


import sys, math
input = lambda : sys.stdin.readline().rstrip()
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		raz = y - x
		mas = []
		for i in range(1, raz + 1):
			if raz % i == 0:
				mas.append(i)
		ans = []
		for i in range(2, 50):
			mas.append(i * raz)
		c = 0
		while True:
			ans = [x]
			count = 1
			vv = x
			vc = 0
			while ans[-1] - mas[c] > 0 and x + (n - vc - 1) * mas[c] > y:
				ans.append(ans[-1] - mas[c])
				vc += 1
			while count < n - vc:
				ans.append(x + mas[c] * count)
				count += 1
			if ans[-1] >= y:
				break
			c += 1
		print(*ans)


def check(d, n, x, y):
	if n < (y - x) // d + 1:
		return 99999999
	n -= (y - x) // d + 1
	lx = x - d
	while n != 0 and lx > 0:
		n -= 1
		lx -= d
	gy = y
	while n != 0:
		n -= 1
		gy += d
	return gy
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	s = set()
	for i in range(1, y - x + 1):
		if (y - x) % i == 0:
			s.add(i)
	ans = 999999999
	diff = -1
	for d in s:
		if ans >= check(d, n, x, y):
			ans = check(d, n, x, y)
			diff = d
	arr = [ans]
	for i in range(n - 1):
		arr += [arr[-1] - diff]
	print(*arr)


def factor(n):
	factors = []
	for i in range(1, n + 1):
		if n % i == 0:
			factors.append(i)
	return factors
testcases = int(input())
for testcase in range(testcases):
	temparr = input()
	temparr = temparr.split()
	n = int(temparr[0])
	x = int(temparr[1])
	y = int(temparr[2])
	if n == 2:
		print(str(x) + ' ' + str(y))
		continue
	diff = y - x
	fact = factor(diff)
	nn = n - 1
	cur = []
	for i in fact:
		cur = []
		cur.append(x)
		curnum = x
		for j in range(nn):
			curnum += i
			cur.append(curnum)
		if y in cur:
			break
	curnum = x
	while True:
		curnum -= i
		if curnum >= 1 and y != cur[-1]:
			cur.insert(0, curnum)
			cur.pop()
		else:
			break
	ans = []
	for i in cur:
		ans.append(str(i))
	print(' '.join(ans))


def print_factors(x):
	res = []
	for i in range(1, x + 1):
		if x % i == 0:
			res.append(i)
	return res
for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	if n == 2:
		print(*[x, y])
	else:
		f = print_factors(y - x)
		for fact in f:
			if (y - x) // fact + 1 <= n:
				res = fact
				break
		ans = [y]
		m = True
		while len(ans) < n:
			if m:
				c = y - len(ans) * res
				if c <= 0:
					m = False
					b = 1
				else:
					ans.append(c)
			else:
				ans.append(y + b * res)
				b += 1
		print(*ans)


import math
for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	p = b - a
	n -= 2
	div = []
	for i in range(1, int(math.sqrt(p)) + 1):
		if p % i == 0:
			if i != p // i:
				div.append(i)
				div.append(p // i)
			else:
				div.append(i)
	div.sort()
	for ele in div:
		if ele * (n + 1) >= p:
			break
	ans = [a, b]
	i = a
	while n > 0 and i < b:
		i += ele
		if i != b:
			ans.append(i)
			n -= 1
	i = a
	while n > 0 and i > 0:
		i -= ele
		if i > 0:
			ans.append(i)
			n -= 1
	i = b
	while n > 0:
		i += ele
		ans.append(i)
		n -= 1
	print(*ans)


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	d = y - x
	l = []
	ll = ''
	k = min(n - 1, d)
	while k > 0:
		if d / k % 1 == 0:
			break
		else:
			k -= 1
	a = d // k
	b = k + 1
	f = x
	for i in range(b):
		ll = ll + str(f) + ' '
		f += a
	x -= a
	while x > 0 and b < n:
		ll = ll + str(x) + ' '
		b += 1
		x -= a
	if b == n:
		pass
	else:
		while b < n:
			y += a
			ll = ll + str(y) + ' '
			b += 1
	print(ll)


def run_case():
	(n, x, y) = map(int, input().split())
	temp = y - x
	flag = 0
	for i in range(n - 1, 0, -1):
		if temp % i == 0:
			flag = temp // i
			break
	mid = temp // flag + 1
	num = 0
	temp = x - flag
	while temp > 0 and num + mid < n:
		num += 1
		temp -= flag
	if num + mid == n:
		res = []
		for i in range(n):
			res.append(y)
			y -= flag
		print(' '.join((str(i) for i in res)))
	else:
		temp += flag
		res = []
		for i in range(n):
			res.append(temp)
			temp += flag
		print(' '.join((str(i) for i in res)))
flag = 1
if flag:
	t = int(input())
	for i in range(t):
		run_case()
else:
	run_case()


import sys, io, os, time
from collections import defaultdict
from collections import Counter
from collections import deque
from itertools import combinations
from itertools import permutations
import bisect, math, heapq
alphabet = 'abcdefghijklmnopqrstuvwxyz'
input = sys.stdin.readline
for ii in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = []
	if n == 2:
		print(x, y)
		continue
	mm = 10 ** 10
	for i in range(1, 51):
		temp = [x]
		c = 1
		while x + c * i <= y:
			temp.append(x + i * c)
			c += 1
		if len(temp) > n:
			continue
		if len(temp) == n and y in temp:
			if mm > y:
				ans = temp
				mm = y
		if len(temp) < n:
			k = x
			c = 1
			while len(temp) < n and k - c * i > 0:
				temp.append(k - c * i)
				c += 1
			k = y
			c = 1
			while len(temp) < n:
				temp.append(k + c * i)
				c += 1
			if mm > k + c * i and x in temp and (y in temp):
				ans = temp
				mm = k + c * i
	print(*ans)


import math
t = int(input())
for w in range(t):
	(n, x, y) = (int(i) for i in input().split())
	if n == 2:
		print(x, y)
	else:
		d = y - x
		l = []
		l1 = []
		for i in range(1, d + 1):
			if d % i == 0:
				l.append(i)
		k1 = 0
		for i in range(len(l)):
			for j in range(1, x + 1):
				if (y - j) % l[i] == 0 and (x - j) % l[i] == 0 and ((y - j) // l[i] <= n - 1):
					k1 = 1
					k = (l[i], j)
					break
			if k1 == 1:
				break
		a = k[1]
		for i in range(n):
			print(a, end=' ')
			a += k[0]
		print()


import math

def get_div(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return sorted(l)
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	arr = get_div(y - x)
	dff = -1
	max_ele = -1
	for i in arr:
		diff = i
		if y - diff * (n - 1) <= x:
			dff = diff
			break
	ans = [y]
	p = y - dff
	cnt = 1
	while p > 0 and cnt < n:
		ans.append(p)
		p -= dff
		cnt += 1
	p = y + dff
	while cnt < n:
		ans.append(p)
		cnt += 1
		p += dff
	print(*ans)


for _ in range(int(input())):
	(l, x, y) = map(int, input().split())
	if x > y:
		(x, y) = (y, x)
	arr = []
	diff = abs(x - y)
	if diff % (l - 1) == 0:
		ind = x
		div = diff // (l - 1)
		while ind != y:
			arr.append(ind)
			ind += div
		arr.append(ind)
	else:
		temp = 0
		while diff % (l - 1) != 0:
			l -= 1
			temp += 1
		ind = x
		div = diff // (l - 1)
		while ind != y:
			arr.append(ind)
			ind += div
		arr.append(ind)
		while x > div and temp > 0:
			temp -= 1
			x -= div
			arr.append(x)
		while temp > 0:
			temp -= 1
			y += div
			arr.append(y)
	print(*arr)


from sys import stdin

def AP(a1, d, n):
	for i in range(n):
		print(a1 + d * i, end=' ')
	print()

def apos(n1, r1, d):
	while r1 > 0:
		if n1 - r1 * d > 0:
			return n1 - r1 * d
		else:
			r1 -= 1
	return n1
for _ in range(int(stdin.readline().rstrip())):
	temp = stdin.readline().rstrip().split()
	r = int(temp[0])
	n1 = int(temp[1])
	n2 = int(temp[2])
	diff = r - 1
	d = 0
	while diff > 0:
		val = (n2 - n1) / diff
		if val.is_integer():
			d = int(val)
			break
		else:
			diff -= 1
	a1 = apos(n1, r - 1 - diff, d)
	AP(a1, d, r)


from math import log2, ceil
from heapq import heappush, heappop, heapify
from copy import deepcopy
from collections import deque, Counter as CC

def main():
	for t in range(int(input())):
		(n, x, y) = [int(j) for j in input().split()]
		d = y - x
		fac = []
		for i in range(1, d + 1):
			if d % i == 0:
				fac.append(i)
		ans = 1e+18
		st = x
		for diff in fac:
			mid = (y - x) // diff + 1
			if mid > n:
				continue
			elif mid == n:
				if y < ans:
					st = x
					ans = y
			else:
				o = n - mid
				mx = (x - 1) // diff
				stt = x - diff * min(o, mx)
				if ans > stt + (n - 1) * diff:
					ans = stt + (n - 1) * diff
					st = stt
		print(' '.join(map(str, [st + x * (ans - st) // (n - 1) for x in range(n)])))
main()


from itertools import permutations
from collections import defaultdict
from math import *
import os
import sys
from io import BytesIO, IOBase
from heapq import nlargest
from bisect import *
import copy
import itertools
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))

def input():
	return sys.stdin.readline().rstrip('\r\n')
t = int(input())
while t:
	t -= 1
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y, end='')
	else:
		dif = y - x
		val = 0
		for i in range(n - 1, 0, -1):
			if dif % i == 0:
				val = dif // i
				break
		k = 0
		ans = []
		for i in range(n):
			ans.append(y - val * k)
			k += 1
		fp = 0
		ans.sort()
		for i in range(n):
			if ans[i] > 0:
				fp = ans[i]
				break
		k = 0
		for i in range(n):
			print(fp + k * val, end=' ')
			k += 1
	print()


import collections
from functools import lru_cache
import bisect
from math import sqrt
INF = float('inf')
NEG_INF = float('inf')
ZERO = 0
ONE = 1

def read():
	return input().strip()

def readInt():
	return int(input().strip())

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

def solve(n, x, y):
	if n == 2:
		return [x, y]
	diff = y - x
	ans = []
	for bw in range(n - 2 + 1):
		newDiff = diff / (bw + 1)
		if int(newDiff) == newDiff:
			newDiff = int(newDiff)
			prev = []
			elemsBetween = []
			end = []
			curr = x
			for i in range(bw + 2):
				elemsBetween.append(curr)
				curr += newDiff
			curr = x - newDiff
			while curr > 0 and len(prev) + len(elemsBetween) < n:
				prev.append(curr)
				curr -= newDiff
			curr = y + newDiff
			while len(prev) + len(elemsBetween) + len(end) < n:
				end.append(curr)
				curr += newDiff
			print(newDiff, prev, elemsBetween, end)
			if not ans or (end and ans[-1] > end[-1]) or (elemsBetween and ans[-1] > elemsBetween[-1]) or (prev and ans[-1] > prev[0]):
				ans = prev[::-1] + elemsBetween + end
		else:
			break
	return ans

def getAnswer(n, x, y, newDiff):
	diff = y - x
	bw = diff // newDiff - 1
	totalBetween = 1 + bw + 1
	if totalBetween > n:
		return []
	prev = []
	elemsBetween = []
	end = []
	curr = x
	for i in range(bw + 2):
		elemsBetween.append(curr)
		curr += newDiff
	curr = x - newDiff
	while curr > 0 and len(prev) + len(elemsBetween) + len(end) < n:
		prev.append(curr)
		curr -= newDiff
	curr = y + newDiff
	while len(prev) + len(elemsBetween) + len(end) < n:
		end.append(curr)
		curr += newDiff
	return prev[::-1] + elemsBetween + end

def getDivisors(num):
	res = [1]
	for i in range(2, int(sqrt(num)) + 1):
		if num % i == 0:
			(one, two) = (i, num // i)
			res.append(one)
			if two != one:
				res.append(two)
	res.append(num)
	return res

def solve2(n, x, y):
	if n == 2:
		return ' '.join(map(str, [x, y]))
	difference = y - x
	ans = []
	for newDifference in getDivisors(difference):
		newAns = getAnswer(n, x, y, newDifference)
		if not ans or (newAns and ans[-1] > newAns[-1]):
			ans = newAns
	return ' '.join(map(str, ans))
t = readInt()
for i in range(t):
	(n, x, y) = readList()
	print(solve2(n, x, y))


t = int(input())
for tt in range(t):
	(n, a, b) = map(int, input().split())
	if (b - a) % (n - 1) == 0:
		d = (b - a) // (n - 1)
		for i in range(a, b + 1, d):
			print(i, end=' ')
		print()
	else:
		m = 0
		for i in range(n - 1, 1, -1):
			if (b - a) % (i - 1) == 0:
				d = (b - a) // (i - 1)
				m = i
				break
		n = n - m
		p = (a - 1) // d
		if p >= n:
			a = a - d * n
		else:
			a = a - d * p
			b = b + d * (n - p)
		for i in range(a, b + 1, d):
			print(i, end=' ')
		print()


t = int(input())
answer = []

def divisor(number):
	result = []
	for i in range(1, number + 1):
		if number % i == 0:
			result.append(i)
	return result
for t in range(t):
	(n, x, y) = list(map(int, input().split(' ')))
	liste = divisor(y - x)
	minimum = float('inf')
	for r in liste:
		gauche = y // r
		if gauche >= n:
			end = y
			begin = y - (n - 1) * r
		if y % r == 0 and gauche == n - 1:
			begin = r
			end = r + y
		if y % r != 0 and gauche == n - 1:
			begin = y % r
		if gauche < n - 1:
			if y % r == 0:
				begin = r
				end = r + (n - 1) * r
			else:
				begin = y % r
				end = y % r + (n - 1) * r
		reponse = []
		count = 0
		while count <= n - 1:
			reponse.append(begin + count * r)
			count += 1
		if reponse[-1] < minimum and begin > 0 and (y in reponse) and (x in reponse):
			minimum = reponse[-1]
			def_reponse = reponse
	for i in range(len(def_reponse)):
		def_reponse[i] = str(def_reponse[i])
	answer.append(' '.join(def_reponse))
print('\n'.join(answer))


from sys import maxsize

def getseries(n, x, y):
	if n == 2:
		return [x, y]
	max_possible_factor_size = y - x
	min_max_elemnt = maxsize
	start = None
	d = None
	for fact in range(1, max_possible_factor_size + 1):
		count = 1
		current_y = y
		isXpresent = False
		while count < n and current_y - fact >= 1:
			current_y -= fact
			if current_y == x:
				isXpresent = True
			count += 1
		if count < n and isXpresent:
			rem_count = n - count
			max_elem = y + fact * rem_count
			if max_elem < min_max_elemnt:
				start = current_y
				d = fact
				min_max_elemnt = max_elem
		if count == n and isXpresent:
			if current_y + (n - 1) * fact < min_max_elemnt:
				start = current_y
				d = fact
				min_max_elemnt = start + (n - 1) * d
	return [start + i * d for i in range(n)]
T = int(input())
while T:
	T -= 1
	(n, x, y) = [int(i) for i in input().split(' ')]
	for i in getseries(n, x, y):
		print(i, end=' ')
	print('')


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	ans = 0
	a2 = 0
	for j in range(n - 1, 0, -1):
		if (x - y) % j == 0:
			ans = (y - x) // j
			a2 = j
			break
	a1 = x // ans + 1
	if a1 + a2 > n:
		a1 = n - a2
	fir = x - ans * (a1 - 1)
	if fir == 0:
		fir += ans
	for j in range(n):
		print(fir + j * ans, end=' ')
	print()


t = int(input())
while t > 0:
	t -= 1
	(n, x, y) = map(int, input().strip().split(' '))
	ele = y - x + 1
	diff = ele - 1
	if n == 2:
		print(x, y)
		continue
	fac = [1, diff]
	for i in range(2, int(diff ** 0.5) + 1):
		if diff % i == 0:
			fac.append(i)
			if diff // i != i:
				fac.append(diff // i)
	fac.sort()
	fdf = 0
	for i in range(len(fac)):
		if diff // fac[i] + 1 == n:
			fdf = fac[i]
			break
	if fdf > 0:
		for i in range(x, y + 1, fdf):
			print(i, end=' ')
		print()
	else:
		for i in range(len(fac)):
			if diff // fac[i] + 1 < n:
				fdf = fac[i]
				break
		nin = diff // fdf + 1
		nin = n - nin
		tmp = x - fdf
		while tmp >= 1 and nin > 0:
			print(tmp, end=' ')
			nin -= 1
			tmp -= fdf
		for i in range(x, y + 1, fdf):
			print(i, end=' ')
		tmp = y + fdf
		while nin > 0:
			print(tmp, end=' ')
			nin -= 1
			tmp += fdf
		print()


for q in range(int(input())):
	(n, x, y) = map(int, input().split())
	for i in range(n - 1, 0, -1):
		if (y - x) % i == 0:
			arr = []
			k = x
			count = 0
			while count < n - i and k > 0:
				arr.append(k)
				k = k - (y - x) // i
				count += 1
			k = x + (y - x) // i
			while len(arr) < n:
				arr.append(k)
				k = k + (y - x) // i
			print(*arr)
			break


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	elif y - x + 1 == n:
		for i in range(x, y + 1):
			print(i, end=' ')
		print()
	elif n > y - x + 1:
		for i in range(x, y + 1):
			print(i, end=' ')
			n = n - 1
		if n == 0:
			print()
			continue
		for i in range(x - 1, 0, -1):
			print(i, end=' ')
			n = n - 1
			if n == 0:
				break
		if n == 0:
			print()
			continue
		for i in range(y + 1, 10 ** 9 + 1):
			print(i, end=' ')
			n = n - 1
			if n == 0:
				break
		print()
	else:
		ans = y - x + 1
		for i in range(n, 0, -1):
			c = ans // i
			k = x
			sum = 1
			for j in range(i):
				k = k + c
				sum += 1
			if k == y and sum <= n:
				break
		ans = x
		if i == 1:
			c = y - x
		for i in range(x, y + 1):
			n -= 1
			print(ans, end=' ')
			if ans == y:
				break
			ans = ans + c
			if n == 0:
				break
		if n == 0:
			print()
			continue
		for i in range(x - c, 0, -c):
			print(i, end=' ')
			n = n - 1
			if n == 0:
				break
		if n == 0:
			print()
			continue
		for i in range(y + c, 10 ** 9, c):
			print(i, end=' ')
			n = n - 1
			if n == 0:
				break
		if n == 0:
			print()
			continue


t = int(input())
for test in range(t):
	(n, x, y) = [int(x) for x in input().split()]
	diff = y - x
	k = n - 1
	while k > 1:
		if diff % k == 0:
			break
		else:
			k -= 1
	tot = n
	val = diff // k
	ans = []
	cnum = x
	while cnum <= y:
		ans.append(cnum)
		cnum += val
		tot -= 1
	cnum = x
	while cnum - val > 0 and tot > 0:
		ans.append(cnum - val)
		cnum = cnum - val
		tot -= 1
	cnum = y
	while tot > 0:
		ans.append(cnum + val)
		cnum = cnum + val
		tot -= 1
	for i in range(n):
		if i == n - 1:
			print(ans[i])
		else:
			print(ans[i], end=' ')


import math
for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	n = n - 2
	if n == 0:
		print(x, y)
		continue
	else:
		print(x, y, end=' ')
		k = y - x
		f = 0
		if k <= n + 1:
			for i in range(x + 1, y):
				print(i, end=' ')
				n = n - 1
			t = x - 1
			while n > 0 and t > 0:
				print(t, end=' ')
				t -= 1
				n -= 1
			t = y + 1
			while n > 0:
				print(t, end=' ')
				t += 1
				n -= 1
			print()
			continue
		for i in range(2, int(math.sqrt(k)) + 1):
			if k % i == 0:
				f = 1
				r = i
				break
		if f == 0 or k == 1:
			if k == 1:
				t = x - 1
				while n > 0 and t > 0:
					print(t, end=' ')
					t -= 1
					n -= 1
				t = y + 1
				while n > 0:
					print(t, end=' ')
					t += 1
					n -= 1
			elif k <= n + 1:
				for i in range(x + 1, y):
					print(i, end=' ')
					n = n - 1
				t = x - 1
				while n > 0 and t > 0:
					print(t, end=' ')
					t -= 1
					n -= 1
				t = y + 1
				while n > 0:
					print(t, end=' ')
					t += 1
					n -= 1
			else:
				t = x - k
				while n > 0 and t > 0:
					print(t, end=' ')
					t -= k
					n -= 1
				t = y + k
				while n > 0:
					print(t, end=' ')
					t += k
					n -= 1
			print()
		else:
			q = k // r - 1
			if q <= n:
				for i in range(x + r, y, r):
					n -= 1
					print(i, end=' ')
				t = x - r
				while n > 0 and t > 0:
					print(t, end=' ')
					t -= r
					n -= 1
				t = y + r
				while n > 0:
					print(t, end=' ')
					t += r
					n -= 1
			else:
				f = 0
				for x1 in range(n + 1, 1, -1):
					if k % x1 == 0:
						f = 1
						r = k // x1
						break
				if f == 1:
					for i in range(x + r, y, r):
						print(i, end=' ')
						n -= 1
					t = x - r
					while n > 0 and t > 0:
						print(t, end=' ')
						t -= r
						n -= 1
					t = y + r
					while n > 0:
						print(t, end=' ')
						t += r
						n -= 1
				else:
					t = x - k
					while n > 0 and t > 0:
						print(t, end=' ')
						t -= k
						n -= 1
					t = y + k
					while n > 0:
						print(t, end=' ')
						t += k
						n -= 1
			print()


import sys
import math
t = int(input())
for j in range(t):
	(n, x, y) = map(int, input().split())
	ans = 1000000007
	ansdiff = 1000000007
	for diff in range(1, y - x + 1):
		if (y - x) % diff != 0:
			continue
		mid = (y - x) // diff + 1
		if mid > n:
			continue
		if mid == n:
			ans = min(ans, y)
			ansdiff = diff
			continue
		left = (x - 1) // diff
		if mid + left >= n:
			ans = min(ans, y)
			ansdiff = diff
			continue
		rightmax = y + (n - mid - left) * diff
		if rightmax < ans:
			ans = rightmax
			ansdiff = diff
	arr = ''
	for i in range(n):
		arr += str(ans) + ' '
		ans = ans - ansdiff
	print(arr)


def FindDivisors(n, list1):
	i = 1
	while i <= n:
		if n % i == 0:
			list1.append(i)
		i = i + 1
b = int(input())
for i in range(b):
	a = []
	(n, x, y) = [int(x) for x in input().split()]
	FindDivisors(y - x, a)
	a[::-1]
	c = len(a)
	e = []
	for i in range(c):
		e.append(y - (n - 1) * a[i])
		if e[i] <= 0:
			if x % a[i] == 0:
				e[i] = x - (x // a[i] - 1) * a[i]
			else:
				e[i] = x - x // a[i] * a[i]
	count = 0
	for i in range(c):
		if x >= e[i]:
			if e[i] <= 0:
				count = x
				count1 = n
				break
			else:
				count = e[i]
				count1 = a[i]
				break
	for i in range(n):
		print(count + i * count1, end=' ')
	print()


t = int(input())
arr = []
for i in range(t):
	(n, x, y) = map(int, input().split())
	arr.append((n, x, y))
for z in arr:
	(n, x, y) = (z[0], z[1], z[2])
	maximum = 100000000000.0
	ans = []
	for start in range(1, x + 1):
		for d in range(1, y - x + 1):
			sup_arr = []
			for j in range(n):
				sup_arr.append(start + j * d)
			if x in sup_arr and y in sup_arr and (max(sup_arr) < maximum):
				ans = sup_arr
				maximum = max(sup_arr)
	for k in ans:
		print(k, end=' ')
	print('')


z = int(input())
for y in range(z):
	(n, a, b) = map(int, input().split())
	arr = [a, b]
	c = b - a
	for i in range(n - 1, 0, -1):
		if c % i == 0:
			d = c // i
			a1 = a
			while a1 + d < b:
				arr.append(a1 + d)
				a1 = a1 + d
			break
	while a - d > 0 and len(arr) < n:
		arr.append(a - d)
		a = a - d
	while len(arr) < n:
		arr.append(b + d)
		b += d
	for item in arr:
		print(item, end=' ')
	print()


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	d = 0
	a1 = 0
	l = []
	for i in range(n - 1, 0, -1):
		if (y - x) % i == 0:
			d = (y - x) // i
			break
	for i in range(1, x + 1):
		if ((x - i) % d == 0 and (y - i) % d == 0) and (y - i) // d <= n - 1:
			a1 = i
			break
	for i in range(n):
		l.append(a1 + i * d)
	print(*l)


for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = abs(x - y)
	for j in range(1, diff + 1):
		if diff % j == 0:
			gp = int(j)
			if gp * (n - 1) >= diff:
				break
	ls = []
	y1 = max(x, y)
	for j in range(n):
		if y1 - j * gp > 0:
			ls.append(y1 - j * gp)
			k1 = j
		else:
			ls.append(y1 + gp * (j - k1))
	ls.sort()
	an = ''
	for a in ls:
		an += str(a) + ' '
	print(an)


for l in [*open(0)][1:]:
	(n, x, y) = map(int, l.split())
	poss = []
	for i in range(1, n):
		if (y - x) % i == 0:
			step = (y - x) // i
			smol = x % step
			if smol == 0:
				smol += step
			tol = smol + step * (n - 1)
			poss.append((max(tol, y), step))
	(tol, step) = min(poss)
	print(*range(tol - step * (n - 1), tol + 1, step))


from sys import stdin
for _ in ' ' * int(stdin.readline()):
	(n, x, y) = map(int, stdin.readline().split())
	ans = -1
	k = y - x
	i = n - 1
	while i > 0:
		if k % i == 0:
			ans = i
			break
		i -= 1
	_1 = []
	for i in range(x, y + 1, k // ans):
		_1.append(i)
	rem = n - (1 + ans)
	gh = x
	f = k // ans
	while rem and gh - f > 0:
		gh -= f
		_1.append(gh)
		rem -= 1
	gh = y
	while rem:
		gh += f
		_1.append(gh)
		rem -= 1
	print(*sorted(_1))


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	dif = y - x
	n1 = n
	for i in range(n - 1, 0, -1):
		if dif % i == 0:
			temp = dif // i
			break
	l = []
	for i in range(x, y + 1, temp):
		l.append(i)
		n -= 1
	i = x - temp
	while i > 0:
		if n == 0:
			break
		l.append(i)
		n -= 1
		i -= temp
	i = y + temp
	while 1:
		if n == 0:
			break
		l.append(i)
		n -= 1
		i += temp
	print(*l)


t = int(input())
for i in range(t):
	(numbers, x, y) = map(int, input().split())
	difference = y - x
	divisor = 0
	for k in range(1, difference + 1):
		if difference % k == 0 and difference // k <= numbers - 1:
			divisor = k
			break
	arr = []
	counter = y
	while numbers and counter >= 1:
		numbers -= 1
		arr.insert(0, counter)
		counter -= divisor
	counter = y
	while numbers:
		numbers -= 1
		arr.append(counter + divisor)
		counter += divisor
	print(*arr)


import math
from collections import deque
for _ in range(int(input())):
	(n, b, c) = map(int, input().split())
	output = deque([])
	x = n
	diff = 0
	while x - 1:
		if (c - b) // (x - 1) == (c - b) / (x - 1):
			diff = (c - b) // (x - 1)
			break
		x -= 1
	n -= x
	if diff:
		output.append(b)
		while output[-1] != c:
			output.append(output[-1] + diff)
	else:
		output.append(b)
		while n and output[0] - diff > 0:
			output.appendleft(output[0] - diff)
			n -= 1
		while n:
			output.append(output[-1] + diff)
			n -= 1
		for i in output:
			print(i, end=' ')
		print()
		continue
	while n and output[0] - diff > 0:
		output.appendleft(output[0] - diff)
		n -= 1
	while n:
		output.append(output[-1] + diff)
		n -= 1
	for i in output:
		print(i, end=' ')
	print()


(z, zz) = (input, lambda : list(map(int, z().split())))
zzz = lambda : [int(i) for i in stdin.readline().split()]
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2 or x == 0:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
num = int(z())
for _ in range(num):
	(n, x, y) = zz()
	for i in range(1, 51):
		for j in range(1, 51):
			c = d = 0
			lst = []
			k = 0
			for _ in range(n):
				nn = j + k
				if nn == x:
					c = 1
				if nn == y:
					d = 1
				lst.append(nn)
				k += i
			if c + d == 2:
				print(*lst)
				break
		if c + d == 2:
			break


t = int(input())
for i in range(t):
	nxy = list(map(int, input().split()))
	n = nxy[0]
	x = nxy[1]
	y = nxy[2]
	y_index = n
	possible_m = []
	possible_k = []
	if (y - x) % (n - 1) == 0:
		counter = 0
		array = []
		for j in range(n):
			array.append(int(j * ((y - x) / (n - 1)) + x))
		print(' '.join((str(i) for i in array)))
	else:
		while y_index >= 1:
			for j in range(x + 1):
				if (y - j) % y_index == 0 and (x - j) % ((y - j) / y_index) == 0 and (j > 0):
					possible_m.append(j)
					possible_k.append(int((y - j) / y_index))
			y_index -= 1
		possible_m.append(x)
		possible_k.append(y - x)
		for j in range(len(possible_m)):
			counter = 0
			array = []
			while counter != n:
				array.append(counter * possible_k[j] + possible_m[j])
				counter += 1
			if x in array and y in array:
				print(' '.join((str(i) for i in array)))
				break


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	for i in range(n - 1, 0, -1):
		if diff % i == 0:
			cd = diff // i
			break
	ans = []
	yc = y
	while yc > 0 and len(ans) < n:
		ans.append(yc)
		yc -= cd
	yc = y + cd
	while len(ans) < n:
		ans.append(yc)
		yc += cd
	print(*ans, sep=' ')


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	dist = y - x
	step = -1
	for i in range(1, dist + 1):
		if dist % i == 0 and dist // i < n:
			step = i
			break
	min_num = x % step
	if min_num == 0:
		min_num += step
	if min_num < y - step * (n - 1):
		min_num = y - step * (n - 1)
	res = [str(min_num + step * i) for i in range(n)]
	print(' '.join(res))


T = int(input().strip())
for t in range(T):
	(n, x, y) = [int(x) for x in input().strip().split(' ')]
	save_arr = [10000000000.0]
	for k in range(n - 1, 0, -1):
		d = (y - x) / (n - k)
		if d.is_integer():
			d = int(d)
		else:
			continue
		arr = [x + i * d for i in range(-k + 1, n - k + 1)]
		neg_nums = sum([1 if x + i * d <= 0 else 0 for i in range(-k + 1, n - k + 1)])
		k -= neg_nums
		arr = [x + i * d for i in range(-k + 1, n - k + 1)]
		if arr[-1] < save_arr[-1]:
			save_arr = arr
	print(' '.join([str(x) for x in arr]))


for T in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	(A, D) = (-1, -1)
	f = False
	for j in range(n, 0, -1):
		for i in range(j - 1, 0, -1):
			if (y - x) % (j - i):
				continue
			d = (y - x) // (j - i)
			a = x - (i - 1) * d
			if a <= 0:
				continue
			elif A == -1 or a + (n - 1) * d < A + (n - 1) * D:
				(A, D) = (a, d)
	for i in range(n):
		print(A + i * D, end=' ')
	print()


T = int(input())
for _ in range(T):
	(n, x, y) = list(map(int, input().split()))
	for k in range(n - 2, -1, -1):
		if (y - x) % (k + 1) == 0:
			d = (y - x) // (k + 1)
			nl = min((x - 1) // d, n - 2 - k)
			l = x - nl * d
			ans = list(range(l, l + (n - 1) * d + 1, d))
			break
	print(' '.join(map(str, ans)))


t = int(input())
for i in range(0, t):
	(e, b, c) = map(int, input().split())
	ct = 0
	for d in range(0, 100):
		for a in range(1, 100):
			l1 = []
			for n in range(1, e + 1):
				yy = a + (n - 1) * d
				l1.append(yy)
			if b in l1 and c in l1:
				ct += 1
				break
		if ct == 1:
			break
	print(*l1, sep=' ')


from sys import stdin, stdout
from math import ceil

def find2(N, X, Y):
	if X == Y:
		return [X] * N
	if Y >= N:
		if X >= Y - N + 1:
			return list(range(Y - N + 1, Y + 1))
		D = Y - X
		for i in range(1, D + 1):
			if D % i == 0 and D // i <= N - 1:
				break
		a = X // i
		a = X - a * i
		if a == 0:
			a = i
		return list(range(a, max(a + i * N, Y + 1), i))[-N:]
	return list(range(1, N + 1))

def find(N, X, Y):
	return ' '.join(map(str, find2(N, X, Y)))

def main():
	for _ in range(int(stdin.readline())):
		(N, X, Y) = list(map(int, stdin.readline().split()))
		print(find(N, X, Y))
main()


import math

def createFactors(start, num):
	a = []
	if start == 0:
		start = 1
	for i in range(start, num + 1):
		if num % i == 0:
			a.append(i)
	return a
t = int(input())
while t > 0:
	t -= 1
	(n, x, y) = map(int, input().split())
	inc = (y - x) // (n - 1)
	a = createFactors(inc, y - x)
	for i in a:
		num = (y - x) / i
		inc = i
		if num == math.ceil(num) and num < n:
			inc = i
			break
	a = x - inc
	while n > 0 and x <= y:
		n -= 1
		print(x, end=' ')
		x += inc
	while a > 0 and n > 0:
		n -= 1
		print(a, end=' ')
		a -= inc
	y += inc
	while n > 0:
		n -= 1
		print(y, end=' ')
		y += inc
	print()


list_ans = []
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	a = y - x
	for i in range(1, a + 1):
		if a % i == 0 and a // i <= n - 1:
			break
	if y - (n - 1) * i >= 1:
		s = y - (n - 1) * i
		list_ans.append(' '.join(map(str, [s + k * i for k in range(n)])))
	else:
		s = y % i
		if s == 0:
			list_ans.append(' '.join(map(str, [i * k for k in range(1, n + 1)])))
		else:
			list_ans.append(' '.join(map(str, [s + k * i for k in range(n)])))
for item in list_ans:
	print(item)


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	r = y - x
	j = 1
	d = -1
	while j <= r and d == -1:
		if r % j == 0 and j * (n - 1) >= r:
			d = j
		j += 1
	g = r // d
	if g - 1 >= n - 2:
		for k in range(x, y + 1, d):
			print(k, end=' ')
		print()
	else:
		bef = (x - 1) // d
		if bef + g - 1 >= n - 2:
			for k in range(x - d * min(bef, n - 1 - g), y + 1, d):
				print(k, end=' ')
			print()
		else:
			l = n
			for k in range(x - d * bef, y + 1, d):
				print(k, end=' ')
				l -= 1
			pr = y + d
			while l > 0:
				print(pr, end=' ')
				pr += d
				l -= 1
			print()


import math
import os
import random
import re
import string
from sys import *
from collections import *

def bs(arr, x, l, r):
	if l <= r:
		mid = (r + l) // 2
		if arr[mid] == x:
			return mid
		elif arr[mid] > x:
			return bs(arr, x, l, mid - 1)
		else:
			return bs(arr, x, mid + 1, r)
	else:
		return -1

def solve():
	for _ in range(int(input())):
		(n, x, y) = map(int, stdin.readline().strip().split())
		if n == 2:
			print(x, y)
		else:
			d = y - x
			a = n - 1
			while a > 0 and d % a != 0:
				a -= 1
			r = d // a
			l = [x, y]
			re = n - 1 - a
			st = x - r
			while re > 0 and st > 0:
				l.append(st)
				re -= 1
				st -= r
			en = y + r
			while re > 0:
				l.append(en)
				en += r
				re -= 1
			st = x + r
			while st < y:
				l.append(st)
				st += r
			print(*l)
solve()


def find_max_divisor(num, limit):
	if limit > num:
		return 1
	min_diff = num
	for d in range(1, num + 1):
		if num % d == 0 and d <= limit:
			min_diff = min(num // d, min_diff)
	return min_diff
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
		continue
	diff = find_max_divisor(y - x, n - 1)
	total_nums = (y - x) // diff + 1
	rem_nums = n - total_nums
	if rem_nums > 0:
		if x - rem_nums * diff > 0:
			start_num = x - rem_nums * diff
		else:
			start_num = x - x // diff * diff
	else:
		start_num = x
	if start_num == 0:
		start_num = diff
	nums = 0
	item = start_num
	while nums < n:
		nums += 1
		print(item, end=' ')
		item += diff
	print('')


input = __import__('sys').stdin.readline
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	bet = y - x
	nstart = n
	n -= 2
	tmp = [(bet // i, i - 1) for i in range(1, bet + 1) if not bet % i]
	start = 0
	minmax = 90000000000.0
	interv = 0
	for (interval, aas) in tmp:
		if aas > n:
			break
		else:
			n2 = n - aas
			tttt = (x - 1) // interval
			if tttt > n2:
				n22 = 0
				tttt = n2
			else:
				n22 = n2 - tttt
			tmptmp = y + interval * n22
			if tmptmp < minmax:
				start = x - tttt * interval
				interv = interval
				minmax = tmptmp
	if nstart == 2:
		print(x, y)
	else:
		print(*[start + i * interv for i in range(nstart)])


t = int(input())
while t > 0:
	t -= 1
	(n, x, y) = map(int, input().split())
	s = y - x
	for i in range(n - 1, -1, -1):
		if s % i == 0:
			j = s // i
			break
	m = y
	k = 0
	for i in range(n):
		print(y, end=' ')
		y -= j
		k += 1
		if y <= 0:
			break
	while k != n:
		k += 1
		print(m + j, end=' ')
		m += j
	print()


import sys
import math, bisect
sys.setrecursionlimit(10 ** 5)
from collections import defaultdict
from itertools import groupby, accumulate
from heapq import heapify, heappop, heappush
from collections import deque, Counter, OrderedDict

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

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

def Neo():
	return list(map(int, sys.stdin.readline().split()))
for _ in range(I()):
	(n, x, y) = neo()
	diff = y - x
	noe = n - 1
	while 1:
		if diff % noe == 0:
			cd = diff // noe
			break
		noe -= 1
	x1 = 0
	while x1 < n:
		if y - x1 * cd <= 0:
			break
		print(y - x1 * cd, end=' ')
		x1 += 1
	i = 1
	while x1 < n:
		print(y + i * cd, end=' ')
		i += 1
		x1 += 1
	print()


from sys import stdin
input = lambda : stdin.readline().strip()
from math import ceil, sqrt, factorial, gcd
from collections import deque
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	l = [x, y]
	t = abs(x - y)
	if n == 2:
		print(*l)
	else:
		l = deque()
		l.append(x)
		for i in range(1, 51):
			if t % i == 0 and t // i - 1 <= n - 2:
				x = i
				break
		while l[-1] != y:
			l.append(l[-1] + x)
		while len(l) != n and l[0] - x >= 1:
			l.appendleft(l[0] - x)
		while len(l) != n:
			l.append(l[-1] + x)
		print(*l)


def find(f, s):
	for i in range(1, f + 1):
		if f % i == 0:
			if f // i <= s:
				return i
for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	step = find(y - x, n - 1)
	used = False
	for i in range(n - 1):
		if y - step * (n - 1) >= 1:
			for j in range(n):
				print(y - step * j, end=' ')
			used = True
			break
		else:
			y += step
	if not used:
		for j in range(n):
			print(x + step * j, end=' ')
	print()


import sys
from math import sqrt, gcd, ceil, log, floor
from bisect import bisect, bisect_left
from collections import defaultdict, Counter, deque
from heapq import heapify, heappush, heappop
input = sys.stdin.readline
read = lambda : list(map(int, input().strip().split()))

def isprime(n, x):
	for i in range(2, int(sqrt(n) + 1)):
		if n % i == 0:
			if n // i - 1 <= x:
				return -i
	return 1

def main():
	ans_ = []
	for _ in range(int(input())):
		(n, x, y) = read()
		diff = abs(y - x)
		if n == 2:
			ans_.append(str(x) + ' ' + str(y))
			continue
		ans = [x, y]
		for i in range(1, 100):
			if diff % i == 0 and diff // i - 1 <= n - 2:
				diff = i
				break
		n -= 2
		z = x
		while z + diff < y:
			z += diff
			ans.append(z)
			n -= 1
		while x - diff > 0 and n > 0:
			x -= diff
			ans.append(x)
			n -= 1
		while n > 0:
			y += diff
			ans.append(y)
			n -= 1
		ans.sort()
		ans_.append(' '.join(map(str, ans)))
	print('\n'.join(ans_))
main()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
		continue
	for j in range(min(y - x + 1, n), 1, -1):
		d = (y - x) / (j - 1)
		if int(d) == d:
			d = int(d)
		else:
			continue
		rem = n - j
		cap = x / d
		if int(cap) == cap:
			cap = int(cap) - 1
		else:
			cap = int(cap)
		cap = min(cap, rem)
		a = x - cap * d
		arr = [a + i * d for i in range(n)]
		print(*arr)
		break


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	l = float('inf')
	for i in range(n):
		for j in range(i + 1, n):
			d = int((y - x) / (j - i))
			if x - i * d > 0 and (y - x) % (j - i) == 0:
				if l > y + (n - j - 1) * d:
					l = y + (n - j - 1) * d
					fi = i
					fj = j
	ans = [0] * n
	ans[fi] = x
	ans[fj] = y
	d = int((y - x) / (fj - fi))
	for i in range(fi - 1, -1, -1):
		ans[i] = x - (i + 1) * d
	for j in range(fi + 1, fj):
		ans[j] = x + (j - fi) * d
	for k in range(fj + 1, n):
		ans[k] = y + (k - fj) * d
	ans.sort()
	print(*ans)


import math, sys, itertools

def printDivisors(a, b):
	n = math.gcd(a, b)
	list = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				list.append(i)
			else:
				list.append(i)
				list.append(int(n / i))
	list.sort()
	return list

def solve(n, a, b):
	ans = []
	dif = b - a
	val = 0
	for i in range(1, dif + 1):
		if dif % i == 0:
			if dif // i <= n - 1:
				val = i
				break
	c = 1
	temp = a
	ans.append(temp)
	while c < n:
		temp = temp + val
		ans.append(temp)
		c += 1
		if temp == b:
			break
	temp = a - val
	while c < n and temp > 0:
		ans.append(temp)
		temp = temp - val
		c += 1
	temp = b
	while c < n:
		temp += val
		ans.append(temp)
		c += 1
	return ans
for _ in range(int(input())):
	(n, a, b) = [int(x) for x in input().split()]
	t = solve(n, a, b)
	for i in t:
		print(i, end=' ')
	print()


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	for i in range(1, y - x + 1):
		if (y - x) % i == 0 and (y - x) / i + 1 <= n:
			if y - i * (n - 1) < 1:
				for t in range(1, x + 1):
					if (x - t) % i == 0:
						for k in range(n):
							num = t + k * i
							print(num, end=' ')
						print()
						break
			else:
				for k in range(n):
					num = y - i * (n - 1) + k * i
					print(num, end=' ')
				print()
			break


import sys
input = sys.stdin.readline

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

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
x = inp()
l = []
rok = 0
ansl = []
for i in range(x):
	rok = 0
	l = []
	(y, a, b) = invr()
	l.append(a)
	l.append(b)
	origy = y
	if y > 3:
		if (b - a) / (y - 2) % 1 == 0:
			diff = (b - a) / (y - 2)
		else:
			diff = (b - a) / (y - 1)
			while not diff % 1 == 0:
				y = y - 1
				diff = (b - a) / (y - 1)
		for i in range(origy - 1):
			l.append(int(l[len(l) - 1] - diff))
			if l[len(l) - 1] - diff < 1:
				rok = 1
				break
		if rok == 1:
			l.sort()
			for i in l:
				if l.count(i) > 1:
					while l.count(i) > 1:
						l.remove(i)
			while not len(l) == origy:
				l.append(int(l[len(l) - 1] + diff))
	elif y == 3:
		if (a + b) / 2 % 1 == 0:
			l.append(int((a + b) / 2))
		else:
			diff = b - a
			if a - diff < 1:
				l.append(int(b + diff))
			else:
				l.append(int(a - diff))
	for i in l:
		if l.count(i) > 1:
			while l.count(i) > 1:
				l.remove(i)
	ansl.append(l)
for i in ansl:
	print(*i)


def min_prod(a, b, x, y, n):
	if n == 0:
		return a * b
	ans1 = min_prod(a - 1, b, x, y, n - 1) if a > x else None
	ans2 = min_prod(a, b - 1, x, y, n - 1) if b > y else None
	if ans1 and ans2:
		return min(ans1, ans2)
	if not ans1 and ans2:
		return ans2
	if not ans2 and ans1:
		return ans1
	return a * b
t = int(input())
while t:
	t -= 1
	(n, x, y) = input().split()
	(n, x, y) = (int(n), int(x), int(y))
	d = None
	for i in range(n - 1, 0, -1):
		if (y - x) % i == 0:
			d = (y - x) // i
			break
	ao = y - (n - 1) * d
	cnt = 0
	i = 0
	while cnt < n:
		term = ao + i * d
		i += 1
		if term > 0:
			print(term, end=' ')
			cnt += 1
	print()


T = int(input())
for t in range(T):
	(n, x, y) = [int(i) for i in input().split()]
	found_flag = False
	for d in range(1, 51):
		if (y - x) % d == 0:
			for a in range(1, x + 1):
				if (x - a) % d == 0 and (y - a) % d == 0 and (a + (n - 1) * d >= y):
					ans = [a + i * d for i in range(n)]
					print(*ans)
					found_flag = True
					break
		if found_flag:
			break


from fractions import Fraction
from collections import defaultdict
import math
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))

def input():
	return sys.stdin.readline().rstrip('\r\n')
krish = 1000
resl = krish - 900
t = int(input())
for _ in range(t):
	(n, x, y) = [int(x) for x in input().split()]
	diff = y - x
	if diff % (n - 1) == 0:
		for i in range(x, y + 1, diff // (n - 1)):
			print(i, end=' ')
		print()
	else:
		lst = []
		no = n - 1
		while no:
			no -= 1
			if no != 0 and diff % no == 0:
				for i in range(x, y + 1, diff // no):
					lst.append(i)
				break
		v = n - len(lst)
		no = lst[1] - lst[0]
		ss = x - no
		if v > 0:
			while ss > 0 and v > 0:
				lst.append(ss)
				v -= 1
				ss -= no
		if v > 0:
			while v > 0:
				lst.append(y + no)
				v -= 1
				y += no
		for i in lst:
			print(i, end=' ')
		print()
		krish += 1


import math
from collections import defaultdict
for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	if n == 2:
		print(x, y)
	else:
		i = n - 1
		diff = y - x
		num = 0
		sp = y - x
		while i >= 2:
			if diff % i == 0:
				num = i - 1
				sp = diff // i
				break
			i -= 1
		num += 2
		elm_l = n - num
		if elm_l == 0:
			for i in range(n):
				print(x, end=' ')
				x += sp
			print()
		else:
			lx = x - 1
			lx_e = lx // sp
			if elm_l >= lx_e:
				j = x - lx_e * sp
				for i in range(n):
					print(j, end=' ')
					j += sp
				print()
			else:
				l = []
				k = x - sp
				for i in range(elm_l):
					l.append(k)
					k -= sp
				j = l[-1]
				for i in range(n):
					print(j, end=' ')
					j += sp
				print()


t = int(input())
for i in range(t):
	string = input()
	nums = string.split()
	n = int(nums[0])
	x = int(nums[1])
	y = int(nums[2])
	difference = (y - x - 1) // (n - 1) + 1
	while True:
		if (y - x) % difference == 0:
			break
		difference += 1
	between = (y - x) // difference + 1
	if between == n:
		lowest = x
	else:
		rest = n - between
		below = (x - 1) // difference
		if below > rest:
			lowest = x - rest * difference
		else:
			lowest = x - below * difference
	for j in range(lowest, lowest + difference * (n - 1) + 1, difference):
		print(j)


def function(n, x, y):
	difference = y - x
	diff = y - x
	d = n - 1
	l = []
	while d > 1 and diff % d != 0:
		d -= 1
	p = int(diff / d)
	k = n
	num = y
	while k > 0 and num > 0:
		l.append(num)
		num -= p
		k -= 1
	num = y
	while k > 0:
		num += p
		l.append(num)
		k -= 1
	print(*l)
t = int(input())
for k in range(t):
	(n, x, y) = map(int, input().rstrip().split())
	function(n, x, y)


def factor(a):
	fact = []
	for jj in range(1, a + 1):
		if a % jj == 0:
			fact.append(jj)
	return fact
for ii in range(int(input())):
	(n, x, y) = map(int, input().split())
	(dif, ans, yy, f) = (abs(x - y), 1, y, True)
	div = factor(dif)
	for jj in div:
		if dif // jj < n:
			ans = jj
			break
	for jj in range(n):
		print(yy, end=' ')
		if f:
			yy -= ans
		else:
			yy += ans
		if yy < 1:
			f = False
			yy = y + ans
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	temp = y - x
	for i in range(n - 1, 0, -1):
		if temp % i == 0:
			d = temp // i
			break
	y1 = y
	c = 0
	c1 = 1
	for i in range(n):
		if y1 - c * d > 0:
			print(y1 - c * d, end=' ')
			c += 1
		else:
			print(y + c1 * d, end=' ')
			c1 += 1
	print()


for TC in range(int(input())):
	(n, x, y) = map(int, input().split())
	INF = float('inf')
	maxval = INF
	step = y - x
	minArr = [INF]
	for i in range(1, step + 1):
		if step % i != 0:
			continue
		if n < step // i + 1:
			continue
		arr = []
		cnt = n
		for t in range(y, -1, -i):
			if t <= 0 or cnt == 0:
				break
			arr.append(t)
			cnt -= 1
		if x not in arr:
			continue
		tmp = 1
		while cnt:
			if cnt == 0:
				break
			arr.append(y + i * tmp)
			cnt -= 1
			tmp += 1
		if max(arr) < max(minArr):
			minArr = [x for x in arr]
	print(*minArr)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	n -= 2
	l = []
	l.append(x)
	l.append(y)
	p = 0
	z = n
	while z > 0:
		if (y - x - 1 - z) % (z + 1) == 0:
			p = (y - x - 1 - z) // (z + 1)
			break
		z -= 1
	if z != 0:
		m = x
		while z > 0:
			z -= 1
			l.append(m + p + 1)
			m = m + p + 1
			n -= 1
	else:
		p = y - x - 1
	if n > 0:
		m = x
		while n > 0:
			if m - p - 1 > 0:
				l.append(m - p - 1)
				m = m - p - 1
			else:
				break
			n -= 1
		while n > 0:
			l.append(y + p + 1)
			y = y + p + 1
			n -= 1
	l.sort()
	print(*l)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	delta = y - x
	for count in range(n - 1, 0, -1):
		if delta % count < 1:
			break
	interval = delta // count
	s = max(y - (n - 1) * interval, (y - 1) % interval + 1)
	print(*range(s, s + interval * n, interval))


import sys
import bisect as bi
import math
from collections import defaultdict as dd
import heapq
import itertools
input = sys.stdin.readline
mo = 10 ** 9 + 7

def cin():
	return map(int, sin().split())

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

def sin():
	return input()

def inin():
	return int(input())
for _ in range(inin()):
	(n, x, y) = cin()
	nma = 1000000000000
	a = 0
	d = 0
	af = df = 0
	for t in range(1, n):
		for k in range(t + 1, n + 1):
			p = t - 1
			q = k - 1
			if (q * x - p * y) % (q - p) == 0:
				a = (q * x - p * y) // (q - p)
				if (y - x) % (q - p) == 0 and a > 0:
					d = (y - x) // (q - p)
					nt = a + (n - 1) * d
					if nt <= nma and d > 0:
						nma = nt
						af = a
						df = d
	l = [0] * n
	for i in range(n):
		l[i] = af + i * df
	print(*l)


import sys, math
input = sys.stdin.readline
t = int(input())
for r in range(t):
	(n, x, y) = map(int, input().split())
	diff = x - y
	mini = 9999999999999999999999999999
	ans = [0, 0]
	for i in range(n):
		for j in range(n):
			if i == j:
				continue
			current = i - j
			if diff % current == 0:
				d = diff // current
				a = x - i * d
				if a > 0 and d > 0:
					an = a + (n - 1) * d
					if an < mini:
						mini = an
						ans = [a, d]
	for i in range(n):
		print(ans[0] + i * ans[1], end=' ')
	print()


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
MAX = int(1000000000.0) + 5

def checkWith(i, j, a, b, n):
	d = (b - a) // (j - i)
	if b - a != d * (j - i):
		return [MAX for x in range(n)]
	firstTerm = a - (i - 1) * d
	if firstTerm <= 0:
		return [MAX for x in range(n)]
	temp = [firstTerm + (x - 1) * d for x in range(1, n + 1)]
	return temp
t = int(input())
for _ in range(t):
	(n, a, b) = map(int, input().split())
	arr = [0 for x in range(n)]
	ansArr = [0 for x in range(n)]
	ans = MAX
	j = n
	while j > 1:
		i = j - 1
		while i:
			temp = checkWith(i, j, a, b, n)
			if max(temp) < ans:
				ansArr = [str(x) for x in temp]
				ans = max(temp)
			i -= 1
		j -= 1
	print(' '.join(ansArr))


for _ in range(int(input())):
	tmp = input().split(' ')
	n = int(tmp[0])
	x = int(tmp[1])
	y = int(tmp[2])
	subs = y - x
	d = 0
	for i in range(1, 51):
		if subs % i == 0 and subs / i + 1 <= n:
			d = i
			break
	a = []
	s = 1
	for i in range(x, y + 1, d):
		if n > 0:
			a.append(i)
			n -= 1
	for i in range(x - d, 0, -d):
		if n > 0:
			a.append(i)
			n -= 1
	for i in range(1, n + 1):
		a.append(y + i * d)
	print(' '.join((str(char) for char in a)))


def solve():
	(n, x, y) = map(int, input().split())
	z = y - x
	m = 1
	for i in range(n - 1, 0, -1):
		if z % i == 0:
			m = z // i
			if z // m <= n:
				break
	R = []
	for i in range(x, y + 1, m):
		R.append(i)
	x = x - m
	while len(R) < n and x > 0:
		R.insert(0, x)
		x -= m
	y += m
	while len(R) < n:
		R.append(y)
		y += m
	for r in R:
		print(r, end=' ')
	print()
for cnt in range(int(input())):
	solve()


def fun(d, n, i):
	if d % i == 0 and n - 1 >= d // i:
		return i
	else:
		return fun(d, n, i + 1)
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	p = y - x
	d = fun(p, n, 1)
	i = x
	while i <= y:
		print(i, end=' ')
		i += d
		n -= 1
	while x - d > 0 and n != 0:
		print(x - d, end=' ')
		x -= d
		n -= 1
	while n > 0:
		print(y + d, end=' ')
		y += d
		n -= 1
	print()


import sys
sys.setrecursionlimit(2000)
from collections import Counter
from functools import reduce
t = [int(val) for val in sys.stdin.readline().split()][0]
for test in range(t):
	(n, x, y) = [int(val) for val in sys.stdin.readline().split()]
	diff = abs(x - y)
	ans = None
	for i in range(1, diff + 1):
		if diff % i == 0 and i * (n - 1) >= diff:
			ans = i
			break
	nums = diff // ans + 1
	rem = n - nums
	maxl = (min(x, y) - 1) // ans
	maxl = min(maxl, rem)
	start = min(x, y) - maxl * ans
	for val in range(start, start + n * ans, ans):
		print(val, end=' ')
	print(' ')


from math import sqrt
from functools import reduce

def factors(n):
	step = 2 if n % 2 else 1
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(sqrt(n)) + 1, step) if n % i == 0)))
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		c = y - x
		s = list(factors(c))
		s.sort()
		g = 0
		for d in s:
			l = []
			c = 0
			while y not in l:
				l.append(x + c * d)
				c = c + 1
			if len(l) < n:
				c = -1
				while x + c * d > 0 and len(l) < n:
					l.append(x + c * d)
					c = c - 1
				c = 1
				while len(l) < n:
					l.append(y + c * d)
					c = c + 1
			if len(l) == n:
				print(*l)
				break


from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
t = int(input())
while t:
	t -= 1
	(n, x, y) = map(int, input().split())
	diff = y - x
	k = list(factors(diff))
	k.sort()
	for ele in k:
		if diff // ele + 1 <= n:
			nt = diff // ele + 1
			break
	if nt < n:
		ans = [i for i in range(y, x - ele, -ele)]
		j = x
		while j >= 1 and nt < n:
			j -= ele
			if j >= 1:
				ans.append(j)
			else:
				break
			nt += 1
		if nt <= n - 1:
			k = y
			while nt < n:
				k += ele
				ans.append(k)
				nt += 1
	else:
		ans = [i for i in range(y, x - ele, -ele)]
	print(*ans)


t = int(input())
a = []
for i in range(t):
	(n, x, y) = map(int, input().split())
	ans = [10 ** 9 for h in range(n)]
	for start in range(1, 51):
		for d in range(1, 51):
			l = [start + j * d for j in range(n)]
			if x in l and y in l:
				if max(ans) > max(l):
					ans = l
	print(*ans, sep=' ')


t = int(input())
for _ in range(t):
	(n, e1, e2) = map(int, input().split())
	result = []
	divisor = n - 1
	remain_elements = n - 1
	while (e2 - e1) % divisor != 0:
		divisor -= 1
	d = (e2 - e1) // divisor
	remain_elements -= divisor
	for i in range(0, divisor + 1):
		result.append(e1 + i * d)
	element_to_add = e1 - d
	while element_to_add > 0 and remain_elements > 0:
		result.append(element_to_add)
		remain_elements -= 1
		element_to_add -= d
	if remain_elements != 0:
		current_e = e2 + d
		for i in range(remain_elements):
			result.append(current_e)
			current_e += d
	for e in result:
		print(e, end=' ')
	print()


T = int(input())

def main():
	(n, x, y) = tuple(map(int, input().split()))
	if n == 2:
		return str(x) + ' ' + str(y)
	diff = abs(x - y)
	index_diff = n - 1
	while index_diff > 0:
		if diff % index_diff == 0:
			arr_diff = diff // index_diff
			break
		else:
			index_diff = index_diff - 1
	result = [min(x, y)]
	for i in range(1, index_diff):
		result.append(result[i - 1] + arr_diff)
	result.append(max(x, y))
	required = n - len(result)
	while result[0] - arr_diff >= 1 and required > 0:
		result = [result[0] - arr_diff] + result
		required -= 1
	if required > 0:
		for i in range(required):
			last = result[-1]
			result.append(last + arr_diff)
	string = ''
	for num in result:
		string = string + str(num) + ' '
	return string
for _ in range(T):
	print(main())


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	e = y - x
	a = e // n
	l = [x + i * a for i in range(n)]
	while y not in l:
		a += 1
		while e % a != 0:
			a += 1
		l = [x + i * a for i in range(n)]
	k = x % a
	while 1:
		l = [k + i * a for i in range(n)]
		k += a
		if x in l and y in l and (0 not in l):
			break
	print(*l)


def make_divisors(n):
	divisors = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			divisors.append(i)
			if i != n // i:
				divisors.append(n // i)
	return divisors

def do():
	q = int(input())
	import math
	from copy import deepcopy
	for _ in range(q):
		(n, x, y) = map(int, input().split())
		a = y - x
		l = make_divisors(a)
		resdat = None
		resmax = 10 ** 10
		for a in l:
			dat = []
			val = y
			for i in range(n):
				dat.append(val)
				val -= a
			if x not in dat or y not in dat:
				continue
			can = []
			val = y
			for i in range(len(dat)):
				if dat[i] >= 1:
					can.append(dat[i])
				else:
					val += a
					can.append(val)
			if max(can) < resmax:
				resmax = max(can)
				resdat = deepcopy(can)
		print(' '.join(list(map(str, resdat))))
do()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	a = y - x
	for i in range(1, a + 1):
		if a % i == 0 and a // i <= n - 1:
			break
	if n == 2:
		print(x, y)
	else:
		q = a // i
		l = []
		j = 0
		z = x % i
		if z == 0:
			z = i
		while z <= y:
			l.append(z)
			z += i
		if len(l) < n:
			for __ in range(n - len(l)):
				l.append(z)
				z += i
		l = l[::-1]
		print(*l[:n])


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	if n >= max(a, b):
		for i in range(1, n + 1):
			print(i, end=' ')
		print()
	else:
		if a < b:
			(a, b) = (b, a)
		for i in range(1, 51):
			l = [0] * 51
			cnt = 0
			bool = False
			for j in range(a, 0, -i):
				l[j] = 1
				cnt += 1
				if j == b:
					bool = True
				if cnt == n:
					break
			if bool:
				break
		cnt = n - cnt
		k = a + i
		add = i
		cntt = 0
		for i in l:
			if i > 0:
				print(cntt, end=' ')
			cntt += 1
		for i in range(cnt):
			print(k, end=' ')
			k += add
		print()


import math

def lower(ele, d, n):
	while ele > 0 and n > 0:
		print(ele, end=' ')
		ele -= d
		n -= 1
	return n

def middle(ele, lst, d, n):
	while ele <= lst:
		print(ele, end=' ')
		ele += d
		n -= 1
	return n

def upper(ele, d, n):
	while n > 0:
		print(ele, end=' ')
		ele += d
		n -= 1
	return n

def isPrime(diff):
	for i in range(2, n + 1):
		if diff % i == 0:
			return False
	return True

def findFactor(diff, n):
	for i in range(1, diff + 1):
		if diff % i == 0:
			xx = diff // i
			if xx < n:
				return i
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	if isPrime(diff):
		print(x, y, end=' ')
		n -= 2
		n = lower(x - diff, diff, n)
		n = upper(y + diff, diff, n)
		print()
		continue
	fac = findFactor(diff, n)
	if fac is None:
		print(x, y, end=' ')
		n -= 2
		n = lower(x, diff, n)
		n = upper(y, diff, n)
	else:
		print(x, y, end=' ')
		n -= 2
		n = middle(x + fac, y - fac, fac, n)
		n = lower(x - fac, fac, n)
		n = upper(y + fac, fac, n)
	print()


import os
import sys
import time
from io import BytesIO, IOBase

def localInput():
	sys.stdin = open('inputf.in', 'r')
	sys.stdout = open('outputf.in', 'w')
	sys.stderr = open('error.txt', 'w')

def print_to_stderr(*a):
	print(*a, file=sys.stderr)
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()]

def solve():
	(n, a, b) = map(int, input().split())
	fans = []
	myfans = []
	diff = 0
	min1 = 99999999999999999
	for i in range(1, min(a, b) + 1):
		for d in range(1, abs(a - b) + 1):
			mylist = []
			for k in range(n):
				mylist.append(i + k * d)
			if a in mylist and b in mylist:
				fans.append(list(mylist))
	for l in fans:
		if l[n - 1] < min1:
			min1 = l[n - 1]
			myfans = list(l)
	print(*myfans)

def main():
	test_cases = int(input())
	for test_units in range(test_cases):
		solve()
execution_time_start = time.clock()
main()
execution_time_stop = time.clock()
print_to_stderr('Total Time Taken: %f Seconds!' % (execution_time_stop - execution_time_start))


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	arr = []
	flag = 0
	if n == 2:
		print(x, y)
		continue
	for d in range(1, y - x + 1):
		if (y - x) % d == 0:
			start = 0
			num = (y - x) // d + 1
			val = num
			if num < n:
				if n - num > (x - 1) // d:
					num += (x - 1) // d
				else:
					num = n
				start = x - d * (num - val)
			else:
				start = x
			if num <= n:
				break
	for i in range(n):
		print(start + i * d, end=' ')
	print()


def process(n, x, y):
	(x, y) = (min(x, y), max(x, y))
	print()
	for i1 in reversed(range(1, n)):
		if (y - x) % i1 == 0:
			c = 0
			flag = 0
			i = (y - x) // i1
			while n > 0:
				t = y - c * i
				if t <= 0 and flag == 0:
					flag = 1
					c = 1
				if flag == 0:
					print(t, end=' ')
				else:
					print(y + c * i, end=' ')
				n -= 1
				c += 1
			return
tests = int(input())
for i in range(tests):
	(n, x, y) = list(map(int, input().split()))
	process(n, x, y)


t = int(input())
while t > 0:
	(n, x, y) = list(map(int, input().split()))
	final = n
	d = y - x
	n = n - 1
	for i in range(n, 0, -1):
		if d % i == 0:
			k = d // i
			l = i
			break
	ans = 1
	z = x
	print(x, end=' ')
	for i in range(l):
		z += k
		print(z, end=' ')
		ans += 1
	while x > 0:
		if ans == final:
			break
		elif x - k > 0:
			print(x - k, end=' ')
			ans += 1
		x -= k
	while ans < final:
		y += k
		print(y, end=' ')
		ans += 1
	print('')
	t -= 1


import sys

def a():
	(n, x, y) = map(int, sys.stdin.readline().split())
	list_res = [0] * n
	res = 1000000400
	for r in range(1, n):
		for l in range(r):
			if l == r:
				continue
			if (y - x) % (r - l):
				continue
			if l * ((y - x) // (r - l)) < x:
				key = (y - x) // (r - l)
				list_res[l] = x
				list_res[r] = y
				for i in range(r + 1, n):
					list_res[i] = list_res[i - 1] + key
				for i in range(l + 1, n):
					list_res[i] = list_res[i - 1] + key
				for i in range(l - 1, -1, -1):
					list_res[i] = list_res[i + 1] - key
				if res > list_res[-1]:
					res = list_res[-1]
					res_res = list_res[:]
				if res == y:
					break
			if res == y:
				break
	print(*list_res)
T = int(sys.stdin.readline())
for _ in range(T):
	a()


T = int(input())

def factors(n):
	i = 1
	ret = []
	while i * i < n:
		if n % i == 0:
			ret.append(i)
			ret.append(n // i)
		i += 1
	if i * i == n:
		ret.append(i)
	return ret

def calculateMax(x, y, d, n):
	number_of_terms = (y - x) // d + 1
	if number_of_terms > n:
		return 3600
	left = n - number_of_terms
	count = 0
	if x % d == 0:
		count = x // d - 1
	else:
		count = x // d
	return y + max(left - count, 0) * d

def printSequence(y, d, n):
	for i in range(n):
		print(y - i * d, end=' ')
	print('')
for i in range(T):
	(n, x, y) = [int(s) for s in input().split()]
	minValue = (calculateMax(x, y, 1, n), 1)
	for j in factors(y - x):
		w = calculateMax(x, y, j, n)
		if minValue[0] > w:
			minValue = (w, j)
	printSequence(minValue[0], minValue[1], n)


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(f'{x} {y}')
		continue
	num = y - x
	divisors = set([1])
	for i in range(1, num + 1):
		if num % i == 0:
			divisors.add(i)
	to_print = list()
	min_value = float('inf')
	divisors = list(divisors)
	for div in divisors:
		ans = [x]
		count = 1
		reachy = False
		while count < n:
			val = ans[-1] + div
			ans.append(val)
			count += 1
			if val == y:
				reachy = True
				break
		if reachy and count < n:
			ans.append(x)
			while count < n:
				val = ans[-1] - div
				if val > 0:
					ans.append(val)
					count += 1
				else:
					break
		if reachy and count <= n:
			ans.append(y)
			while count < n:
				val = ans[-1] + div
				ans.append(val)
				count += 1
		if count == n and reachy:
			maxxxx = max(ans)
			if maxxxx < min_value:
				min_value = maxxxx
				ans = list(set(ans))
				to_print = ans.copy()
	print(*to_print, sep=' ')


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	for i in range(n, 0, -1):
		if (y - x) % i == 0:
			i = (y - x) // i
			if y - x <= (n - 1) * i:
				z = max((y - 1) % i + 1, y - n * i + i)
				print(*(z + j * i for j in range(n)))
				break


import math
t = int(input())
for i in range(t):
	(n, a, b) = map(int, input().strip().split(' '))
	temp = n
	k = math.ceil((b - a) / (n - 1))
	k = int(k)
	f = 0
	for j in range(k, b - a):
		if (b - a) % j == 0:
			f = 1
			d = j
			break
	if f == 0:
		d = b - a
	n -= (b - a) // d + 1
	if n == 0:
		lst = []
		for j in range(0, temp):
			lst.append(a + d * j)
	else:
		l = (a - 1) // d
		if l >= n:
			lst = []
			for j in range(1, n + 1):
				lst.insert(0, a - d * j)
			j = 0
			p = 0
			while p != b:
				p = a + d * j
				lst.append(p)
				j += 1
		else:
			lst = []
			for j in range(1, l + 1):
				lst.insert(0, a - d * j)
			j = 0
			p = 0
			while p != b:
				p = a + d * j
				lst.append(p)
				j += 1
			n -= l
			for j in range(1, n + 1):
				lst.append(b + j * d)
	for j in range(temp):
		print(lst[j], end=' ')
	print()


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	check = 0
	ho = y - x
	for i in range(1, ho // 2 + 1):
		if ho % i == 0 and ho // i + 1 <= n:
			check = i
			break
	if check != 0:
		output = [x for x in range(y, 0, -check)][:n][::-1]
		for _ in range(n - len(output)):
			output.append(output[-1] + check)
	else:
		output = [x for x in range(y, 0, -ho)][:n][::-1]
		for _ in range(n - len(output)):
			output.append(output[-1] + ho)
	print(*output)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	dif = y - x
	divide = 0
	ans = []
	val = 0
	for i in range(1, dif // 2 + 1):
		if dif % i == 0 and dif // i - 1 <= n - 2:
			divide = dif // i
			val = i
			break
	n -= 2
	if divide != 0:
		for i in range(1, divide):
			ans.append(x + i * val)
			n -= 1
	ans.append(x)
	ans.append(y)
	if val == 0:
		val = dif
	x -= val
	while x > 0 and n > 0:
		ans.append(x)
		x -= val
		n -= 1
	if n > 0:
		for i in range(1, n + 1):
			ans.append(y + i * val)
	for i in range(len(ans)):
		print(ans[i], end=' ')
	print('')


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	nt = n
	f = 10 ** 18
	dt = -1
	at = -1
	for a in range(1, 51):
		for d in range(1, 51):
			n = nt
			f1 = 0
			f2 = 0
			b = a
			if b == x:
				f1 = 1
			elif b == y:
				f2 = 1
			n -= 1
			while n > 0:
				n -= 1
				b += d
				if b == x:
					f1 = 1
				elif b == y:
					f2 = 1
			if f1 == 1 and f2 == 1 and (b < f):
				f = b
				at = a
				dt = d
	for i in range(nt):
		print(at, end=' ')
		at += dt
	print()


import math

def printf(ar, minn, maxx, diff, l):
	for i in ar:
		cnt = 0
		if diff // i + 1 > l:
			continue
		if diff // i + 1 == l:
			return list(range(minn, maxx + 1, i))
		if diff // i + 1 < l:
			cnt += diff // i + 1
			m = minn
			mm = maxx
			while m - i > 0 and cnt < l:
				m = m - i
				cnt += 1
			if cnt == l:
				return list(range(m, maxx + 1, i))
			elif m - i <= 0 and cnt < l:
				while cnt < l:
					mm = mm + i
					cnt += 1
				if cnt == l:
					return list(range(m, mm + 1, i))
for i in range(int(input())):
	(l, minn, maxx) = map(int, input().split())
	diff = maxx - minn
	factors = set()
	for i in range(1, math.ceil(math.sqrt(diff)) + 1):
		if diff % i == 0:
			factors.add(i)
			factors.add(diff // i)
	f_ar = sorted(list(factors))
	print(*printf(f_ar, minn, maxx, diff, l))


def readGenerator():
	while True:
		tokens = input().split(' ')
		for t in tokens:
			yield t
reader = readGenerator()

def readWord():
	return next(reader)

def readInt():
	return int(next(reader))

def readFloat():
	return float(next(reader))

def readLine():
	return input()

def solve(n):
	return n

def solve(n, x, y):
	res = 1000000000000
	for dist in range(1, n):
		if (y - x) % dist != 0:
			continue
		d = (y - x) // dist
		cl = (y - 1) // d
		if cl + 1 >= n:
			res = min(res, y)
			if res == y:
				a = [str(res - i * d) for i in range(0, n)]
		else:
			res = min(res, y + (n - cl - 1) * d)
			if res == y + (n - cl - 1) * d:
				a = [str(res - i * d) for i in range(0, n)]
	return ' '.join(a)
tests = readInt()
for _ in range(0, tests):
	n = readInt()
	x = readInt()
	y = readInt()
	print(solve(n, x, y))


def div(k):
	d = []
	for i in range(1, 1 + int(k ** 0.5)):
		if k % i == 0:
			d.append(i)
			if k // i > i:
				d.append(k // i)
	d.sort()
	return d
for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		z = y - x
		d = div(z)
		ans = [x]
		for i in d:
			if x + i * (n - 1) >= y:
				for j in range(z // i):
					ans.append(i + ans[-1])
				break
		z = ans[1] - ans[0]
		while len(ans) < n and ans[0] - z > 0:
			ans.insert(0, ans[0] - z)
		while len(ans) < n:
			ans.append(ans[-1] + z)
		print(*ans)


import sys

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

def main():
	t = Iint()
	for _ in range(t):
		(n, x, y) = Imap()
		f = factorise(y - x)
		for fi in f:
			if x >= y - fi * (n - 1) > 0:
				s = y - fi * (n - 1)
				x = [s + i * fi for i in range(n)]
				Plist(x)
				break
		else:
			debug('in 2')
			for fi in f:
				if y - x > fi * n:
					continue
				debug(fi, y % fi)
				mi = y % fi
				if mi == 0:
					mi += fi
				if mi + (n - 1) * fi >= y:
					Plist([mi + i * fi for i in range(n)])
					break
en = enumerate
FIO = 10
BUFSIZE = 8 * 1024

def debug(*args, c=6):
	pass

def Istr():
	return input()

def Iint():
	return int(input())

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

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

def Plist(li, s=' '):
	print(s.join(map(str, li)))
if not FIO:
	if __name__ == '__main__':
		main()
		exit()
else:
	from io import BytesIO, IOBase
	import os

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))

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


def fun(n, a, b):
	m = n
	if n == 2:
		print(a, end=' ')
		print(b)
		return
	else:
		diff = b - a
		while diff % (n - 1) != 0:
			n = n - 1
			if n == 1:
				break
		temp = int(diff / (n - 1))
		count = 0
		temp1 = a
		lis = []
		while m > n and temp1 - temp > 0:
			lis.append(temp1 - temp)
			m = m - 1
			temp1 = temp1 - temp
		while count < n:
			lis.append(a)
			a += temp
			count += 1
			m = m - 1
		while m > 0:
			lis.append(a)
			a = a + temp
			m = m - 1
		print(*lis)
t = int(input())
for i in range(t):
	(n, a, b) = input().split()
	n = int(n)
	a = int(a)
	b = int(b)
	fun(n, a, b)


import collections

def solve():
	(n, x, y) = map(int, input().split())
	for i in range(1, y - x + 1):
		if (y - x) % i == 0 and (y - x) // i + 1 <= n:
			d = collections.deque()
			for j in range(x, y + 1, i):
				d.append(j)
			while len(d) < n and d[0] - i > 0:
				d.appendleft(d[0] - i)
			while len(d) < n:
				d.append(d[-1] + i)
			for j in d:
				print(j, end=' ')
			print()
			return
t = int(input())
for i in range(t):
	solve()


import sys
import math
import collections
import bisect
import itertools
import decimal
import copy
INF = 10 ** 20
ni = lambda : int(sys.stdin.readline().rstrip())
ns = lambda : map(int, sys.stdin.readline().rstrip().split())
na = lambda : list(map(int, sys.stdin.readline().rstrip().split()))
na1 = lambda : list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))

def main():
	t = ni()
	for _ in range(t):
		(n, x, y) = ns()
		dist = y - x
		max_sep = 0
		for i in range(n - 1, 0, -1):
			if dist % i == 0:
				max_sep = i
				break
		sep = dist // max_sep
		ans = list(range(x, y + 1, dist // max_sep))
		while len(ans) < n:
			if ans[0] - sep > 0:
				ans.insert(0, ans[0] - sep)
			else:
				break
		while len(ans) < n:
			ans.append(ans[-1] + sep)
		print(*ans, sep=' ')
main()


import time

def solve():
	(n, x, y) = map(int, input().split())
	c = y - x
	i = 1
	while True:
		if c % i == 0 and i * n > c:
			break
		i += 1
	a = x // i
	k = x - a * i
	arr = []
	for _ in range(n):
		arr.append(k + _ * i)
	while True:
		if x not in arr or y not in arr:
			arr.pop(0)
			arr.append(arr[-1] + i)
		else:
			break
	if arr[0] == 0:
		arr.pop(0)
		arr.append(arr[-1] + i)
	arr = list(map(str, arr))
	print(' '.join(arr))
t = int(input())
for x in range(t):
	solve()


def main():
	t = int(input())
	for _ in range(t):
		(n, y, x) = map(int, input().split())
		diff = x - y
		for i in range(1, diff + 1):
			if diff % i == 0 and diff // i <= n - 1:
				factor = i
				break
		l = []
		for j in range(y, x + 1, factor):
			if n == 0:
				break
			l.append(j)
			n -= 1
		for k in range(y - factor, 0, -factor):
			if n == 0:
				break
			l.append(k)
			n -= 1
		for e in range(x + factor, 10 ** 10, factor):
			if n == 0:
				break
			l.append(e)
			n -= 1
		print(*l)
main()


for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	a = []
	for j in range(1, n):
		if (y - x) % (n - j) == 0:
			e = (y - x) // (n - j)
			for i in range(x, y + 1, e):
				a.append(i)
			break
	l = len(a)
	if l < n:
		d = n - l
		while x - e > 0 and d > 0:
			a.append(x - e)
			x = x - e
			d -= 1
	l = len(a)
	if l < n:
		d = n - l
		while d > 0:
			a.append(y + e)
			y = y + e
			d -= 1
	print(*a)


from sys import stdout
from sys import stdin

def get():
	return stdin.readline().strip()

def getf():
	return [int(i) for i in get().split()]

def put(a, end='\n'):
	stdout.write(str(a) + end)

def putf(a, sep=' ', end='\n'):
	stdout.write(sep.join(map(str, a)) + end)

def isint(a):
	return int(a) == a

def solve(x, y, n):
	(minD, minFst) = (10 ** 9 + 1, 10 ** 9 + 1)
	for fst in range(1, x + 1):
		for d in range(1, 50):
			k1 = (x - fst) / d
			k2 = (y - fst) / d
			if isint(k1) and isint(k2) and (k1 < n) and (k2 < n):
				if fst + d * (n - 1) < minFst + minD * (n - 1):
					(minD, minFst) = (d, fst)
	a = [minFst]
	for i in range(n - 1):
		a += [a[-1] + minD]
	return a

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


t = int(input())
for tc in range(1, t + 1):
	(n, a, b) = map(int, input().split())
	if n == 2:
		print(a, b)
		continue
	diff = b - a
	nn = n - 1
	while diff % nn:
		nn -= 1
	gap = diff // nn
	res = []
	c = a
	while c <= b and len(res) < n:
		res.append(c)
		c += gap
	if len(res) == n:
		for i in res:
			print(i, end=' ')
		print()
		continue
	c = a - gap
	while c > 0 and len(res) < n:
		res.append(c)
		c -= gap
	if len(res) == n:
		for i in res:
			print(i, end=' ')
		print()
		continue
	c = b + gap
	while len(res) < n:
		res.append(c)
		c += gap
	for i in res:
		print(i, end=' ')
	print()


from math import gcd
for _ in range(int(input())):
	X = list(map(int, input().split()))
	Dif = X[-1] - X[-2]
	Check = Dif
	for i in range(1, Dif + 1):
		if Dif % i == 0 and X[-1] // i - X[-2] // i < X[0]:
			Check = i
			break
	Counter = 0
	for i in range(X[-1], 0, -Check):
		print(i, end=' ')
		X[0] -= 1
		if X[0] == 0:
			break
	print(*range(X[-1] + Check, X[-1] + Check * X[0] + 1, Check))


T = int(input())
for z in range(T):
	(n, x, y) = [int(x) for x in input().split()]
	diff = y - x
	i = n - 1
	brac = 0
	while i >= 1:
		brac = diff / i
		if brac - int(brac) == 0:
			break
		else:
			i -= 1
	collected = i + 1
	possmall = (x - 1) // brac
	req = n - collected
	start = 0
	if req <= possmall:
		start = x - req * brac
	else:
		start = x - possmall * brac
	for i in range(n):
		if i == n - 1:
			e = ''
		else:
			e = ' '
		print(int(start + i * brac), end=e)
	print('')


import sys
si = sys.stdin.readline

def main():
	t = int(si())
	while t:
		t -= 1
		(n, x, y) = [int(e) for e in si().split()]
		(diff, l, cnt) = (y - x, [], n)
		for i in range(n, 1, -1):
			if not diff % (i - 1):
				d = diff // (i - 1)
				temp = x
				while temp <= y:
					l.append(temp)
					temp += d
					cnt -= 1
				temp = x - d
				while cnt and temp >= 1:
					l.append(temp)
					temp -= d
					cnt -= 1
				while cnt:
					y += d
					l.append(y)
					cnt -= 1
				break
		for e in l:
			print(e, end=' ')
		print()
main()


import sys
IN = sys.stdin.readline
for _ in range(int(IN())):
	(n, x, y) = map(int, IN().split())
	d = 1
	for i in range(n, 1, -1):
		if (y - x) % (i - 1) == 0:
			d = i - 1
			break
	if d == 1 and y - x > 1:
		print(x, '', y, '', end='')
		diff = y - x
		x -= diff
		n -= 2
		while n > 0 and x > 0:
			print(x, '', end='')
			x -= diff
			n -= 1
		for _ in range(n):
			print(y + diff, '', end='')
			y += diff
		print()
	else:
		diff = int((y - x) / d)
		y += diff
		for i in range(x, y, diff):
			print(i, '', end='')
			n -= 1
		x -= diff
		while n > 0 and x > 0:
			print(x, '', end='')
			x -= diff
			n -= 1
		while n > 0:
			print(y, '', end='')
			y += diff
			n -= 1
		print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	l = y - x
	i = 1
	ma = 0
	while i * i <= l:
		if l % i == 0:
			if i >= ma and i + 1 <= n:
				ma = i
			c = l // i
			if c >= ma and c + 1 <= n:
				ma = c
		i += 1
	d = l // ma
	left = n - ma - 1
	if x % d == 0:
		mm = x // d - 1
	else:
		mm = x // d
	if mm >= left:
		print(*range(y - n * d + d, y + 1, d))
	else:
		m = y + (left - mm) * d
		print(*range(m - n * d + d, m + 1, d))


for t in range(int(input())):
	(n, x, y) = [int(k) for k in input().split()]
	if n == 2:
		print(x, y)
		continue
	else:
		for i in range(n - 1, 0, -1):
			no = (y - x) / i
			if no % 1 == 0:
				no = int(no)
				if y > (n - 1) * no:
					for i in range(n):
						print(y - i * no, end=' ')
					print()
					break
				else:
					init = y % no
					if init == 0:
						init = no
					for i in range(n):
						print(init + i * no, end=' ')
					print()
					break


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	ans = 1
	for i in range(n - 1, 0, -1):
		if (y - x) % i == 0:
			ans = i
			break
	ans2 = []
	for j in range(i + 1):
		ans2.append(x + j * (y - x) // ans)
	j = 1
	while x - j * (y - x) // ans > 0 and len(ans2) < n:
		ans2.append(x - j * (y - x) // ans)
		j += 1
	j = 1
	while len(ans2) < n:
		ans2.append(y + j * (y - x) // ans)
		j += 1
	print(*ans2)


import math
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	d = y - x
	diff = 0
	for i in range(n - 1, 0, -1):
		if d % i == 0:
			diff = d // i
			break
	temp = y
	c = 0
	while temp > 0 and c < n:
		print(temp, end=' ')
		temp -= diff
		c += 1
	temp = y + diff
	while c < n:
		print(temp, end=' ')
		temp += diff
		c += 1
	print()


t = int(input())
for _ in range(t):
	(n, x, y) = list(map(int, input().split()))
	dAns = -1
	maxYans = 10000000000
	for indexDiff in range(1, n):
		if (y - x) % indexDiff == 0:
			nums = indexDiff + 1
			if nums > n:
				continue
			d = (y - x) // indexDiff
			extraNums = (x - 1) // d
			maxY = y
			if not extraNums >= n - nums:
				maxY += (n - nums - extraNums) * d
			if maxY < maxYans:
				maxYans = maxY
				dAns = d
	ans = [maxYans - d * i for i in range(n)]
	print(' '.join(map(str, ans)))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = 0
	delete = y - x
	result = [y]
	for i in range(n, 1, -1):
		if delete % (i - 1) == 0:
			diff = int(delete / (i - 1))
			break
	for i in range(n - 1):
		result.append(y - (i + 1) * diff)
	temp = 0
	if result[-1] < 0:
		temp = int(abs(result[-1]) // diff)
		if abs(result[-1]) % diff != 0:
			temp += 1
		temp *= diff
	if temp + result[-1] == 0:
		temp += diff
	if temp != 0:
		for i in range(n):
			result[i] += temp
	result = result[::-1]
	for i in range(n):
		print(result[i], end=' ')
	print('')


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = [x, y]
	d = n
	count = 2
	while d:
		if (y - x) % d == 0 and d <= n - 1:
			break
		d -= 1
	if count != n:
		diff = (y - x) // d
		c = x + diff
		while c != y and count < n:
			count += 1
			ans.append(c)
			c += diff
		if count < n:
			x -= diff
			while x > 0 and count < n:
				count += 1
				ans.append(x)
				x -= diff
		if count < n:
			y += diff
			while count < n:
				count += 1
				ans.append(y)
				y += diff
	print(*ans)


def calc(x, y, i, n):
	bet = (y - x) // i - 1
	pre = x // i
	if bet + 2 > n:
		return (i, 2 ** 31)
	elif bet + pre + 2 >= n:
		return (i, y)
	else:
		r = n - (bet + pre)
		return (i, y + r * i)

def prans(x, y, i, n):
	ans = [x, y]
	for j in range((y - x) // i - 1):
		ans.append((j + 1) * i + x)
	bet = (y - x) // i - 1
	if len(ans) < n:
		for j in range(min(x // i, n - (bet + 2))):
			if x - (j + 1) * i > 0:
				ans.append(x - (j + 1) * i)
	if len(ans) < n:
		l = len(ans)
		for j in range(n - l):
			ans.append((j + 1) * i + y)
	for num in ans:
		print(num, end=' ')
	print()
test = int(input())
for _ in range(test):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(min(x, y), end=' ')
		print(max(x, y))
	else:
		d = y - x
		ans = 2 ** 31
		di = d
		for i in range(1, d + 1):
			if d % i == 0:
				(div, ex) = calc(x, y, i, n)
				if ex < ans:
					di = div
					ans = ex
		prans(x, y, di, n)


def solve():
	(n, x, y) = map(int, input().split())
	diff = y - x
	if n == 2:
		print(x, y)
		return
	for i in range(1, diff + 1):
		if diff % i != 0:
			continue
		k = diff // i - 1
		if k + 2 > n:
			continue
		arr = [x + j * i for j in range(k + 2)]
		if len(arr) < n:
			begin = [x - (j + 1) * i for j in range(n - len(arr)) if x - (j + 1) * i > 0]
		else:
			print(' '.join(map(str, arr)))
			return
		if len(begin) + len(arr) < n:
			end = [y + (j + 1) * i for j in range(n - len(arr) - len(begin))]
		else:
			print(' '.join(map(str, begin + arr)))
			return
		print(' '.join(map(str, begin + arr + end)))
		return
for _ in range(int(input())):
	solve()


from math import inf
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	n -= 2
	p = (0, inf, 0)
	if not n:
		print(f'{x} {y}')
	else:
		d = y - x
		for i in range(d, 0, -1):
			if d % i == 0:
				m = n - (d // i - 1)
				if m >= 0:
					if x // i - 1 >= m:
						p = (x - m * i, y, i)
						break
					else:
						a = x // i if x % i else x // i - 1
						m -= a
						if p[1] > y + m * i:
							p = (x - a * i, y + m * i, i)
		print(*[x for x in range(p[0], p[1] + 1, p[2])])


from math import ceil, floor
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	left = 0
	while (y - x) % (n - 1) != 0:
		n -= 1
		left += 1
	diff = (y - x) // (n - 1)
	ans = [x]
	for i in range(n - 1):
		tmp = ans[-1] + diff
		ans.append(tmp)
	while left and ans[0] - diff > 0:
		tmp = ans[0] - diff
		ans.insert(0, tmp)
		left -= 1
	while left:
		tmp = ans[-1] + diff
		ans.append(tmp)
		left -= 1
	print(*ans)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	a = []
	for i in range(1, y - x + 1):
		if (y - x) % i == 0:
			a.append(y)
			while len(a) < n:
				if a[-1] - i < 1:
					break
				a.append(a[-1] - i)
			if len(a) < n:
				a.append(y + i)
				while len(a) < n:
					a.append(a[-1] + i)
			if a.__contains__(x) and a.__contains__(y):
				print(*a)
				break
			else:
				a.clear()


import bisect

def factor(x):
	lis = []
	for i in range(1, x + 1):
		if x % i == 0:
			lis.append(i)
	return lis
for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	if n == 2:
		print(' '.join([str(x), str(y)]))
	else:
		diff = y - x
		lis = factor(diff)
		new = []
		for i in lis:
			if diff // i > n:
				pass
			else:
				new.append(i)
		ans = -1
		final = []
		for no in new:
			now = []
			(xi, yi) = (x, y)
			while xi - no > 0:
				xi -= no
			while len(now) < n or now[-1] < y:
				now.append(xi)
				xi += no
			x_poses = bisect.bisect_left(now, x)
			for x_pos in range(x_poses + 1):
				if x_pos + n - 1 < len(now) and now[x_pos + n - 1] >= y:
					if ans == -1 or now[x_pos + n - 1] < ans:
						ans = now[x_pos + n - 1]
						final = now[x_pos:x_pos + n]
		final = list(map(str, final))
		print(' '.join(final))


for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	di = y - x
	midi = y - x
	for i in range(2, n):
		if di % i == 0:
			midi = di // i
	res = []
	for i in range(n):
		if y > i * midi:
			res.append(y - i * midi)
		else:
			break
	u = 1
	while len(res) < n:
		res.append(y + u * midi)
		u += 1
	print(' '.join(map(str, res)))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	m = 100000000000
	for i in range(1, n):
		if (y - x) % i == 0:
			diff = (y - x) // i
		m = min(m, diff)
	diff = m
	a = [x, y]
	for i in range(x + diff, y, diff):
		if len(a) == n:
			break
		a.append(i)
	if len(a) < n:
		m = min((x - 1) // diff, n - len(a))
		temp = x - diff
		for i in range(m):
			a.append(temp)
			temp -= diff
	if len(a) < n:
		i = y + diff
		while True:
			if len(a) == n:
				break
			a.append(i)
			i += diff
	for i in a:
		print(i, end=' ')
	print('')


for _ in range(int(input().strip())):
	(n, x, y) = tuple(map(int, input().strip().split()))
	step = y - x
	for i in range(n - 1, 1, -1):
		diff = y - x
		if diff % i == 0:
			step = diff / i
			break
	li = []
	i = x
	co = 0
	while i != y + step:
		li.append(i)
		i += step
		co += 1
	i = x
	if co < n:
		while i - step >= 1 and co < n:
			i -= step
			li.append(i)
			co += 1
		while co < n:
			li.append(max(li) + step)
			co += 1
	for i in li:
		print(int(i), sep='', end=' ')
	print()


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	diff = y - x
	for delta in range(1, diff + 1):
		if diff % delta:
			continue
		if int(diff / delta + 1) > n:
			continue
		k = min(int((y - 1) / delta), n - 1)
		a0 = y - k * delta
		break
	for j in range(n):
		print('{} '.format(a0 + j * delta), end='')
	print()


t = int(input())
for it in range(1, t + 1):
	(n, x, y) = input().split()
	n = int(n)
	x = int(x)
	y = int(y)
	solfound = 0
	while not solfound:
		for iy in range(n, 1, -1):
			for ix in range(iy - 1, 0, -1):
				step = (y - x) / (iy - ix)
				if step % 1 == 0 and x - step * (ix - 1) > 0:
					solfound = 1
				if solfound == 1:
					break
			if solfound == 1:
				break
	x0 = int(x - step * (ix - 1))
	xnp1 = int(x + step * (n - ix + 1))
	for ip in range(x0, xnp1, int(step)):
		print(int(ip), end=' ')
	print('\n')


import sys
pin = sys.stdin.readline
for t in range(int(pin())):
	(N, x, y) = map(int, pin().split())
	(x, y) = (min(x, y), max(x, y))
	D = y - x
	n = N
	while D % (n - 1):
		n -= 1
	d = D // (n - 1)
	M = y // d + int(y % d > 0)
	m = min(M, N)
	for i in range(y, y - m * d, -d):
		print(i, end=' ')
	if M < N:
		for i in range(y + d, y + d * (N - M + 1), d):
			print(i, end=' ')
	print()


import bisect
import collections
import functools
import itertools
import math
import heapq
import random
import string

def repeat(_func=None, *, times=1):

	def decorator(func):

		@functools.wraps(func)
		def wrapper(*args, **kwargs):
			for _ in range(times):
				func(*args, **kwargs)
		return wrapper
	if _func is None:
		return decorator
	else:
		return decorator(_func)

def unpack(func=int):
	return map(func, input().split())

def l_unpack(func=int):
	return list(map(func, input().split()))

def s_unpack(func=int, rev=False):
	return sorted(map(func, input().split()), reverse=rev)

def ml_unpack(n):
	return [int(input()) for _ in range(n)]

def range_n():
	return range(int(input()))

def getint():
	return int(input())

def factor(n):
	d = {}
	while not n % 2:
		d[2] = d.get(2, 0) + 1
		n //= 2
	i = 3
	while i * i <= n:
		while not n % i:
			d[i] = d.get(i, 0) + 1
			n //= i
		i += 2
	if n > 1:
		d[n] = d.get(n, 0) + 1
	return d

def get_sum(a):
	ans = 0
	n = len(a)
	for i in range(n):
		ans += (i - (n - i - 1)) * a[i]
	return ans

@repeat(times=getint())
def main():
	(n, x, y) = unpack()
	ans = [0] * n
	(p, q) = (0, 0)
	for i in range(n):
		for j in range(i + 1, n):
			if not (y - x) % (j - i) and j - i >= q - p:
				(p, q) = (i, j)
	d = (y - x) // (q - p)
	ans[p] = x
	for i in range(p - 1, -1, -1):
		ans[i] = ans[i + 1] - d
	for i in range(p + 1, n):
		ans[i] = ans[i - 1] + d
	if ans[0] <= 0:
		for i in range(n):
			if ans[i] <= 0:
				ans.append(ans[-1] + d)
			else:
				ans = ans[i:]
				break
	print(*ans)
main()


from sys import stdin, stdout
from math import gcd, log2, log10, floor
import math
from collections import defaultdict
input = stdin.readline

def constructarray(x, y, n, difference):
	l = list(range(x, y + 1, difference))
	if len(l) > n:
		return None
	while len(l) < n:
		x -= difference
		if x <= 0:
			break
		l.append(x)
	while len(l) < n:
		y += difference
		l.append(y)
	return (l, y)

def fun(n, x, y, diff):
	l1 = [x, y]
	maxa1 = float('inf')
	for i in reversed(range(1, y - x + 1)):
		if (y - x) % i == 0:
			numbers = (y - x) // i + 1
			if numbers <= n:
				(l, maxa) = constructarray(x, y, n, i)
				if maxa1 > maxa:
					maxa1 = maxa
					l1 = l
	return l1
for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	a = fun(n, x, y, diff)
	print(*a)


diff = [[i for i in range(1, 50) if not a % i] for a in range(50)]

def get_diff(n, x, y):
	p = y - x
	for i in diff[p]:
		if p // i < n:
			return i
for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff_n = get_diff(n, x, y)
	a = list(range(y, 0, -diff_n))[:n]
	nr = n - len(a)
	ar = list(range(y + diff_n, y + diff_n + diff_n * nr, diff_n))
	print(*a, *ar)


import time, math as mt, bisect as bs, 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, x, y) = IP()
	mn = 2000000000.0
	for i in range(1, 51):
		if (y - x) % i == 0:
			vl = (y - x) // i + 1
			if vl <= n:
				mx = x + (n - 1) * i
				if mx < mn:
					ans = i
					mn = mx
	li = [i for i in range(x, y + 1, ans)]
	x = len(li)
	while x < n:
		pos = li[0] - ans
		if pos >= 1:
			li.insert(0, pos)
		else:
			li.append(li[-1] + ans)
		x += 1
	print(*li)
	return
t = II()
for i in range(t):
	solve()


from sys import stdin
from math import ceil, gcd
from functools import reduce

def factors(n, p):
	return list(set(reduce(list.__add__, ([i - 1, n // i - 1] for i in range(1, min(int(n ** 0.5), p) + 1) if n % i == 0))))
for _ in range(int(stdin.readline())):
	(n, x, y) = map(int, stdin.readline().split())
	arr = [0] * n
	fac = factors(y - x, n)
	fac = list(filter(lambda x: x <= n - 2, fac))
	fac.sort()
	m = fac[-1]
	arr[0] = x
	arr[1] = y
	p = (y - x) // (m + 1)
	for i in range(2, m + 2):
		arr[i] = x + (i - 1) * p
	c = 1
	mi = x
	Ma = y
	for i in range(m + 2, n):
		if c == 1:
			if mi - p > 0:
				arr[i] = mi - p
				mi -= p
			else:
				arr[i] = Ma + p
				Ma += p
				c = 0
		else:
			arr[i] = Ma + p
			Ma += p
	print(*arr)


from sys import *
ws = lambda : map(int, stdin.readline().strip().split())
li = lambda : list(map(int, stdin.readline().strip().split()))
mod = 1000000007

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(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def prod(l):
	ans = 1
	for i in range(len(l)):
		ans = ans * l[i]
	return ans

def sortindex(l, a):
	c = []
	if a == -1:
		rev = True
	else:
		rev = False
	for i in range(len(l)):
		c.append([l[i], i])
	x = sorted(c, reverse=rev)
	print(x)
	c = []
	for i in range(len(l)):
		c.append(x[i][1])
	return c
for testcases in range(int(input())):
	(n, x, y) = ws()
	if n == 2:
		print(x, y)
		continue
	diff = y - x
	key = 0
	for i in range(1, diff + 1):
		if diff % i != 0:
			continue
		temp = diff / i
		temp += 1
		if temp > n:
			continue
		else:
			key = i
			break
	for i in range(int(temp)):
		print(x + key * i, end=' ')
	temp1 = n - temp
	flag = 0
	j = 0
	for i in range(int(temp1)):
		nice = x - key * (i + 1)
		if flag == 0:
			if nice <= 0:
				j = 1
				flag = 1
		if flag == 0:
			print(nice, end=' ')
		else:
			print(y + key * j, end=' ')
			j += 1
	print()


t = int(input())
for _ in range(t):
	(n, lo, hi) = map(int, input().split())
	diff = hi - lo
	if diff % (n - 1) == 0:
		step = diff // (n - 1)
		print(*[i for i in range(lo, hi + step, step)])
	else:
		for i in range(1, diff + 1):
			if diff // i < n and diff % i == 0:
				step = i
				break
		n_left = n - diff // step - 1
		left = list(range(lo, 0, -step))
		if n_left < len(left):
			lowest = left[n_left]
		else:
			lowest = min(left)
		print(*[i for i in range(lowest, lowest + step * n, step)])


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
from collections import deque

def main():

	def solve():
		(n, x, y) = [int(x) for x in input().split()]
		diff = y - x
		for numOfInserted in range(n - 2, -1, -1):
			commonDistance = diff / (numOfInserted + 1)
			if commonDistance.is_integer():
				commonDistance = int(commonDistance)
				break
		array = deque([x])
		for i in range(numOfInserted + 1):
			array.append(array[-1] + commonDistance)
		while len(array) < n:
			newElement = array[0] - commonDistance
			if newElement > 0:
				array.appendleft(newElement)
			else:
				break
		while len(array) < n:
			array.append(array[-1] + commonDistance)
		print(' '.join(map(lambda x: str(x), array)))
	t = int(input())
	for i in range(t):
		solve()
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()


from collections import deque
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	a = min(x, y)
	b = max(x, y)
	diff = b - x
	for i in reversed(range(1, n)):
		if diff % i == 0:
			break
	d = diff // i
	ans = deque([b])
	t = b - d
	while len(ans) != n and t > 0:
		ans.appendleft(t)
		t -= d
	t = b + d
	while len(ans) != n:
		ans.append(t)
		t += d
	print(*ans)


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')
for j in range(int(input())):
	(n, x, y) = map(int, input().split())
	left = n - 2
	diff = y - x
	if n == 2:
		print(*[x, y])
	else:
		divisors = []
		diff = y - x
		setty = set()
		for s in range(1, y - x + 1):
			if (y - x) % s == 0 and (not s in setty):
				divisors.append(s)
				setty.add(s)
		for d in divisors:
			tempn = n
			rem = x % d
			lbound = (x - x % d) // d
			rbound = (y - y % d) // d
			tempn -= rbound - lbound + 1
			if rem != 0:
				v0 = min(min(lbound, tempn), lbound)
				lbound -= v0
				tempn -= v0
			else:
				v0 = min(min(lbound, tempn), lbound - 1)
				lbound -= v0
				tempn -= v0
			rbound += tempn
			arr1 = [rem + d * s for s in range(lbound, rbound + 1)]
			set2 = set(arr1)
			if x in set2 and y in set2 and (len(arr1) == n):
				print(*arr1)
				break


l = []
for i in range(1, 51):
	temp = []
	for j in range(1, i + 1):
		if i % j == 0:
			temp.append(i // j)
	temp.sort()
	l.append(temp)
t = int(input())
for i in range(t):
	(n, a, b) = map(int, input().split())
	diff = b - a
	val = l[diff - 1]
	maximum = 100000000000000000000000000000000
	max_diff = 0
	for x in val:
		tot = x + 1
		if tot > n:
			continue
		difference = diff // x
		tem = (a - 1) // difference
		tot += tem
		max_value = b if tot >= n else b + (n - tot) * difference
		if max_value < maximum:
			maximum = min(max_value, maximum)
			max_diff = difference
	for j in range(n):
		print(maximum - max_diff * j, end=' ')
	print()


import atexit
import io
import sys
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER

@atexit.register
def write():
	sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
for case in range(int(input())):
	(n, x, y) = [int(x) for x in input().split()]
	m = 10 ** 9 + 1
	for i in range(1, 51):
		for j in range(1, 51):
			r = range(i, n * j + i, j)
			if x in r and y in r:
				s = max(r)
				if s < m:
					m = s
					ans = [x for x in r]
	print(*ans)


t = int(input())
for _ in range(t):
	(n, x, y) = list(map(int, input().split()))
	best_max = 10 ** 9
	best_arr = None
	for i in range(n):
		for j in range(i + 1, n):
			possible = (y - x) % (j - i)
			if possible == 0:
				d = (y - x) // (j - i)
				max_ele = y + (n - 1 - j) * d
				min_ele = x - d * i
				if min_ele <= 0:
					continue
				if max_ele < best_max:
					best_arr = (min_ele, d)
					best_max = max_ele
	final_arr = []
	(m, d) = best_arr
	for i in range(n):
		final_arr.append(m + d * i)
	print(' '.join(map(str, final_arr)))


test_cases = int(input())
for test_case in range(test_cases):
	(n, x, y) = list(map(int, input().split()))
	maxdiff = 50
	newn = n - 2
	if n > 2:
		mindiff = (y - x) // newn
	else:
		mindiff = maxdiff
	c = 0
	ans = []
	for i in range(1, maxdiff):
		for j in range(1, 50):
			ans = [j]
			count = 0
			while True:
				j += i
				ans.append(j)
				if len(ans) == n:
					if x in ans and y in ans:
						c = 1
						break
					else:
						break
				count += 1
			if c == 1:
				break
		if c == 1:
			break
	print(*ans)


for j in range(int(input())):
	(n, x, y) = map(int, input().split())
	left = n - 2
	diff = y - x
	if n == 2:
		print(*[x, y])
	else:
		divisors = []
		diff = y - x
		setty = set()
		for s in range(1, y - x + 1):
			if (y - x) % s == 0 and (not s in setty):
				divisors.append(s)
				setty.add(s)
		for d in divisors:
			tempn = n
			rem = x % d
			lbound = (x - x % d) // d
			rbound = (y - y % d) // d
			tempn -= rbound - lbound + 1
			if rem != 0:
				v0 = min(min(lbound, tempn), lbound)
				lbound -= v0
				tempn -= v0
			else:
				v0 = min(min(lbound, tempn), lbound - 1)
				lbound -= v0
				tempn -= v0
			rbound += tempn
			arr1 = [rem + d * s for s in range(lbound, rbound + 1)]
			set2 = set(arr1)
			if x in set2 and y in set2 and (len(arr1) == n):
				print(*arr1)
				break


from __future__ import division, print_function
from sys import stdin, stdout
import bisect
import math
import heapq
i_m = 9223372036854775807

def inin():
	return int(input())

def stin():
	return input()

def spin():
	return map(int, stin().split())

def lin():
	return list(map(int, stin().split()))

def matrix(n):
	return [list(map(int, input().split())) for i in range(n)]

def string2intlist(s):
	return list(map(int, s))

def calculate_sum(a, N):
	m = N / a
	sum = m * (m + 1) / 2
	ans = a * sum
	return ans

def series(N):
	return N * (N + 1) // 2

def count2Dmatrix(i, list):
	return sum((c.count(i) for c in list))

def modinv(n, p):
	return pow(n, p - 2, p)

def GCD(x, y):
	x = abs(x)
	y = abs(y)
	if min(x, y) == 0:
		return max(x, y)
	while y:
		(x, y) = (y, x % y)
	return x

def LCM(x, y):
	return x * y // GCD(x, y)

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l

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

def SieveOfEratosthenes(n):
	global prime
	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
	f = []
	for p in range(2, n):
		if prime[p]:
			f.append(p)
	return f
q = []

def dfs(n, d, v, c):
	global q
	v[n] = 1
	x = d[n]
	q.append(n)
	j = c
	for i in x:
		if i not in v:
			f = dfs(i, d, v, c + 1)
			j = max(j, f)
	return j
for _ in range(inin()):
	(n, x, y) = spin()
	d = sorted(Divisors(y - x))
	temp = 0
	m = 10 ** 9
	t = [10 ** 9 + 1]
	for i in d:
		l = []
		for j in range(y, 0, -i):
			if len(l) == n:
				break
			l.append(j)
		if x not in l and y not in l:
			continue
		for j in range(y + i, 10 ** 9, i):
			if len(l) == n:
				break
			l.append(j)
		if x in l and y in l and (len(l) == n):
			if max(l) < max(t):
				t = l
	print(*t)


from bisect import bisect_right

def solve(p, n):
	i = n - 1
	while i >= 1:
		if p % i == 0:
			return [i, p // i]
		i -= 1
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	s = solve(y - x, n)
	diff = s[1]
	p = y
	a = []
	for i in range(n):
		a.append(p)
		p -= diff
	if a[-1] <= 0:
		for i in range(n):
			a[i] = a[i] + 1 - a[-1]
		a = a[::-1]
		if y not in a:
			p = bisect_right(a, y)
			s = y - a[p - 1]
			for i in range(n):
				a[i] += s
	print(*a[::-1])


for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		a = y - x
		b = 0
		g = n - 1
		if g != 0:
			while a % g != 0:
				b += 1
				g -= 1
				if g == 0:
					exit
		c = int(a / g)
		e = []
		t = 1
		for f in range(n):
			r = y - f * c
			if r > 0:
				e.append(r)
			else:
				e.append(y + t * c)
				t += 1
		print(*e)


from collections import *
from sys import stdin, stderr

def rl():
	return [int(w) for w in stdin.readline().split()]
for _ in range(rl()[0]):
	(n, x, y) = rl()
	d = 1
	while (n - 1) * d < y - x or (y - x) % d:
		d += 1
	a1 = max((y - 1) % d + 1, y - (n - 1) * d)
	print(*(a1 + i * d for i in range(n)))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	jump = y - x
	for i in range(1, jump + 1):
		if jump % i == 0:
			x = jump // i
			if x < n:
				steps = (y - 1) // i
				ans = max(y, y + (n - steps - 1) * i)
				a = ans - (n - 1) * i
				print(*list(range(a, ans + 1, i)[::-1]))
				break


for _ in range(int(input())):
	(n, x, y) = [int(i) for i in input().split()]
	dif = y - x
	res = n * y
	for i in range(1, dif + 1):
		if dif % i == 0:
			step = dif // i + 1
			if step <= n:
				poss_step = (x + i - 1) // i - 1
				allst = step + poss_step
				if allst >= n:
					res = y
					step_size = i
				elif res > y + i * (n - allst):
					res = y + i * (n - allst)
					step_size = i
	res_seq = [res - (n - i - 1) * step_size for i in range(n)]
	print(*res_seq)


import math
t = int(input())
for p in range(t):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		num = y - x
		diff = 0
		for i in range(n - 2 + 1, 0, -1):
			if num % i == 0:
				diff = num // i
				break
		ans = []
		for i in range(x, y + 1, diff):
			ans.append(i)
		if len(ans) != n:
			while x > diff:
				ans.append(x - diff)
				x = x - diff
				if len(ans) == n:
					break
		if len(ans) != n:
			rem = n - len(ans)
			while rem > 0:
				y = y + diff
				ans.append(y)
				rem -= 1
		print(*ans)


def iin():
	return int(input())

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

def main():
	t = iin()
	while t:
		t -= 1
		(n, x, y) = lin()
		n2 = n - 1
		df = y - x
		ans = []
		for i in range(1, df + 1):
			if df % i == 0:
				ln = df // i
				if ln <= n2:
					ans = list(range(x, y + 1, i)) + list(range(x - i, 0, -i)) + list(range(y + i, y + i * n, i))
					break
		print(*ans[:n])
main()


import math

def getDivisors(n, divisors):
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				divisors.append(i)
			else:
				divisors.append(i)
				divisors.append(n // i)
		i += 1

def solve(d, divisors, n, x, y):
	arr = []
	arr.append(y)
	n -= 1
	i = 1
	num = y - i * d
	while num > 0 and n != 0:
		arr.append(num)
		i += 1
		n -= 1
		num = y - i * d
	i = 1
	while n != 0:
		num = y + i * d
		arr.append(num)
		i += 1
		n -= 1
	if x in arr:
		print(*arr)
		return True
	return False
for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	diff = y - x
	divisors = []
	getDivisors(diff, divisors)
	divisors.sort()
	for d in divisors:
		if solve(d, divisors, n, x, y):
			break


from sys import stdin, stdout
from os import path
if path.exists('input.txt'):
	stdin = open('input.txt', 'r')
for _ in range(int(stdin.readline())):
	(n, x, y) = map(int, stdin.readline().strip().split())
	f = n - 1
	d = left = 0
	while True:
		if (y - x) % f == 0:
			d = (y - x) // f
			break
		f -= 1
	out = []
	i = 0
	while x + d * i <= y and n > 0:
		out.append(x + d * i)
		i += 1
		n -= 1
	x -= d
	while x > 0 and n > 0:
		out.append(x)
		x -= d
		n -= 1
	y += d
	while n > 0:
		out.append(y)
		y += d
		n -= 1
	print(*out)


def solve(n, x, y):
	for i in range(n - 1, 0, -1):
		if (y - x) % i != 0:
			continue
		r = (y - x) // i
		array = []
		a = y
		while a > 0:
			array.append(a)
			if len(array) == n:
				return array
			a -= r
		a = y + r
		while len(array) < n:
			array.append(a)
			a += r
		return array
for _ in range(int(input())):
	(n, x, y) = [int(x) for x in input().split()]
	print(*solve(n, x, y))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
		continue
	for i in range((y - x) // n + 1, y - x + 1):
		if (y - x) % i == 0:
			cnt = i
			break
	i = 1
	j = 1
	li = [y]
	while n - 1:
		if y - i * cnt > 0:
			li.append(y - i * cnt)
			i += 1
			n -= 1
		else:
			li.append(y + j * cnt)
			j += 1
			n -= 1
	print(*li)


def solve(n, x, y):
	if y >= n >= y - x + 1:
		return range(y - n + 1, y + 1)
	if y < n:
		return range(1, n + 1)
	for step in range(2, 51):
		if y - x <= (n - 1) * step and (y - x) % step == 0:
			cur = y
			ans = []
			while len(ans) < n and cur > 0:
				ans.append(cur)
				cur -= step
			cur = y + step
			while len(ans) < n:
				ans.append(cur)
				cur += step
			return ans
	return
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	print(*solve(n, x, y))


t = int(input())
while t > 0:
	(n, x, y) = list(map(int, input().split()))
	if n == 2:
		print(x, y)
	else:
		ans = []
		min_ = float('inf')
		for d in range(1, y - x + 1):
			temp = [y]
			temp2 = [y]
			for j in range(n - 1):
				if temp[-1] - d > 0:
					temp.append(temp[-1] - d)
				else:
					temp2.append(temp2[-1] + d)
			temp.reverse()
			temp += temp2[1:]
			if x in temp:
				ans = temp
				break
		print(*temp)
	t -= 1


import math
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	t = 10000
	for a in range(1, x + 1):
		for i in range(1, 51):
			flag = 0
			temp = []
			for j in range(1, n + 1):
				p = a + (j - 1) * i
				temp.append(p)
			c = 0
			for q in temp:
				if q == x:
					c = 1
				elif q == y and c == 1:
					c = 2
				if c == 2:
					flag = 1
					break
			if flag == 1:
				break
		if t > max(temp):
			t1 = temp[:]
			t = max(temp)
	print(*t1)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
		continue
	n_temp = n
	while (y - x) % (n_temp - 1) != 0:
		n_temp -= 1
	d = (y - x) // (n_temp - 1)
	arr = []
	z = x
	while z <= y:
		arr.append(z)
		z += d
	if len(arr) < n:
		z = x - d
		while z > 0 and len(arr) < n:
			arr.append(z)
			z -= d
	if len(arr) < n:
		z = y + d
		while len(arr) < n:
			arr.append(z)
			z += d
	print(*arr)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = y - x
	for i in range(1, n):
		if (y - x) % i == 0:
			d = min(d, (y - x) // i)
	z = 0
	while x - (z + 1) * d > 0 and x + (n - 1 - (z + 1)) * d >= y:
		z += 1
	a = [x + (k - z) * d for k in range(n)]
	print(*a)


t = int(input())
for i in range(t):
	(a, x, y) = input().split()
	a = int(a)
	x = int(x)
	y = int(y)
	mx = 999999999
	ans = []
	for p in range(1, 50):
		for q in range(1, 50):
			lst = [p * i + q for i in range(a)]
			if x in lst and y in lst and (mx > max(lst)):
				mx = max(lst)
				ans = lst
	print(*ans)


t = input()
t = int(t)

def solve(n, x, y):
	for d in range(1, 50):
		if (y - x) % d == 0 and (y - x) // d < n:
			break
	if y >= d * n:
		arr = list(range(y - (n - 1) * d, y + d, d))
	else:
		start = y % d
		if start == 0:
			start = d
		arr = list(range(start, start + n * d, d))
	print(' '.join(list(map(str, arr))))
for i in range(t):
	(n, x, y) = map(int, input().split())
	solve(n, x, y)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	a = 0
	for i in range(n - 1, -1, -1):
		if (y - x) % i == 0:
			a = i
			break
	a = (y - x) // a
	b = y
	i = n
	while b > 0 and i > 0:
		print(b, end=' ')
		i -= 1
		b -= a
	y += a
	while i > 0:
		print(y, end=' ')
		i -= 1
		y += a
	print()


import os
from heapq import heapify, heappop, heappush
import sys
import math
import operator
import bisect
from collections import defaultdict
from io import BytesIO, IOBase
sys.setrecursionlimit(10 ** 5)

def inpt():
	return [int(k) for k in input().split()]

def main():
	for _ in range(int(input())):
		(n, a, b) = inpt()
		dif = abs(a - b)
		if n == 0:
			print(a, b)
		else:
			for i in range(1, dif + 1):
				ans = [a]
				ok = False
				temp = n - 1
				p = a
				while temp and p != b:
					p += i
					temp -= 1
					ans.append(p)
					if p == b:
						ok = True
						break
				if ok:
					t = a - i
					while temp and t > 0:
						ans.append(t)
						temp -= 1
						t -= i
					t = b + i
					while temp:
						ans.append(t)
						t += i
						temp -= 1
					for i in ans:
						print(i, end=' ')
					print()
					break
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')
main()


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	div = n - 1
	while div > 1:
		if (y - x) % div == 0:
			break
		div -= 1
	div = (y - x) // div
	ans = []
	x = y
	while x > 0 and n > len(ans):
		ans.append(x)
		x -= div
	for _ in range(n - len(ans)):
		y += div
		ans.append(y)
	print(' '.join(map(str, ans)))


for _ in range(int(input())):
	(num, one, two) = map(int, input().split())
	num1 = num - 1
	diff = two - one
	while diff % num1 != 0:
		num1 -= 1
	diff1 = diff // num1
	lis = [x for x in range(one, two + 1, diff1)]
	num2 = num - len(lis)
	if num2 == 0:
		for m in lis:
			print(m, end=' ')
	else:
		x = lis[0]
		while x - diff1 > 0 and num2 != 0:
			lis.append(x - diff1)
			num2 = num - len(lis)
			x -= diff1
		else:
			if num2 != 0:
				for y in range(num2):
					lis.append(max(lis) + diff1)
		for m in lis:
			print(m, end=' ')


t = int(input())
for i in range(t):
	(a, b, c) = map(int, input().split())
	if a == 2:
		print(b, c)
	else:
		for j in range(1, c - b + 1):
			if (c - b) % j == 0:
				if (c - b) // j + 1 <= a:
					lol = j
					break
		kek = []
		for j in range(b, c + 1, lol):
			kek.append(j)
		hmm = a - len(kek)
		if kek[0] - lol > 0 and hmm > 0:
			for j in range(kek[0] - lol, 0, -lol):
				kek.append(j)
				hmm -= 1
				if hmm == 0:
					break
		kek.sort()
		if hmm > 0:
			for j in range(kek[len(kek) - 1] + lol, 10 ** 18, lol):
				kek.append(j)
				hmm -= 1
				if hmm == 0:
					break
		print(*kek)


import os
from io import BytesIO, IOBase
import sys
from math import ceil

def main():
	for t in range(int(input())):
		(n, x, y) = map(int, input().split())
		if n == 2:
			print(x, y)
		elif y > n:
			if (y - x) % (n - 1) == 0:
				for i in range(x, y + 1, (y - x) // (n - 1)):
					print(i, end=' ')
				print(' ')
			else:
				d = y - x
				flag = 0
				for i in range(1, d + 1):
					if d % i == 0 and (y - x) // i < n:
						flag = i
						break
				j = 0
				if flag == 0:
					flag = d
				start = y - (n - 1) * flag
				if start < 0:
					start = start + ceil(abs(start) / flag) * flag
				if start == 0:
					start = flag
				while j < n:
					print(start, end=' ')
					start += flag
					j += 1
				print(' ')
		else:
			for i in range(1, n + 1):
				print(i, end=' ')
			print('')
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')
main()


import sys
input = sys.stdin.buffer.readline

def solution():
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		l = []
		d = y - x
		flag = 0
		for i in range(1, d + 1):
			if d % i == 0:
				if d // i - 1 > n - 2:
					continue
				else:
					z = i
					for q in range(x, y + 1, z):
						l.append(q)
					flag = 1
					break
		if flag:
			l1 = []
			q = x - z
			while q > 0 and len(l1) + len(l) != n:
				l1.append(q)
				q -= z
			if len(l1) > 0:
				l = l1 + l
			while len(l) != n:
				a = l[-1] + z
				l.append(a)
		else:
			z = y - x
			q = x
			while q > 0 and len(l) != n - 1:
				l.append(q)
				q -= z
			l.reverse()
			while len(l) != n:
				q = l[-1] + z
				l.append(q)
		print(*l)
t = int(input())
for _ in range(t):
	solution()


import sys

def input():
	return sys.stdin.readline()[:-1]

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

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

def getIntList():
	return list(getIntIter())
for _ in range(int(input())):
	(n, x, y) = getIntIter()
	diffXY = y - x
	diff = 0
	for a in range(1, diffXY + 1):
		if diffXY % a != 0:
			continue
		if a * (n - 1) >= diffXY:
			diff = a
			break
	possUpToY = (y + diff - 1) // diff
	if y - diff * (n - 1) > 0:
		out = list((y - diff * a for a in range(n)))
		print(str(out)[1:-1].replace(',', ' '))
	else:
		mod = y % diff
		if mod == 0:
			mod = diff
		out = list((mod + diff * a for a in range(n)))
		print(str(out)[1:-1].replace(',', ' '))


t = int(input())
for j in range(0, t):
	(n, x, y) = map(int, input().split())
	m = n
	while (y - x) % (n - 1) != 0:
		n = n - 1
	o = (y - x) // (n - 1)
	ww = 0
	l = []
	for j in range(x, y + 1, o):
		l.append(str(j))
	ww = len(l)
	eee = 0
	if ww == m:
		eee = ' '.join(l)
		print(eee)
	else:
		x = x - o
		while x > 0:
			l.append(str(x))
			x = x - o
			ww = ww + 1
			if ww == m:
				break
		if ww == m:
			eee = ' '.join(l)
			print(eee)
		else:
			y = y + o
			while ww != m:
				l.append(str(y))
				y = y + o
				ww = ww + 1
			eee = ' '.join(l)
			print(eee)


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())

	def soln():
		for step in range(1, y - x + 1):
			if (y - x) % step != 0:
				continue
			curr = []
			goingForwards = False
			for _ in range(n):
				if len(curr) == 0:
					curr.append(y)
				elif not goingForwards and curr[-1] - step > 0:
					curr.append(curr[-1] - step)
				elif not goingForwards:
					goingForwards = True
					curr.append(y + step)
				else:
					curr.append(curr[-1] + step)
			if x in curr:
				return curr
	result = soln()
	print(' '.join(map(str, result)))


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	mx = 10 ** 9
	ans = []
	for i in range(0, n - 1):
		for j in range(i + 1, n):
			if (y - x) % (j - i) == 0 and x - (y - x) / (j - i) * i > 0:
				rz = (y - x) // (j - i)
				st = x - (y - x) // (j - i) * i
				ms = []
				for k in range(n):
					ms.append(st)
					st += rz
				if ms[-1] < mx:
					mx = ms[-1]
					ans = ms.copy()
	print(*ans)


for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	m = 0
	for i in range(1, y - x + 1):
		if (y - x) % i == 0:
			a = (y - x) // i + 1
			if a <= n:
				c = n - a
				while c > 0 and x - i > 0:
					x -= i
					c -= 1
				while c > 0:
					y += i
					c -= 1
				ans = [v for v in range(x, y + 1, i)]
				print(*ans)
				break


def solver(n, x, y):
	best = float('inf')
	for start in range(1, 50):
		for diff in range(1, y - x + 1):
			arr = generator(start, diff, n)
			if x in arr and y in arr:
				if arr[n - 1] < best:
					best = arr[n - 1]
					bestarr = arr
	return ' '.join((str(ele) for ele in bestarr))

def generator(start, diff, n):
	a = [0] * n
	a[0] = start
	for i in range(1, n):
		a[i] = a[i - 1] + diff
	return a
for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	print(solver(n, x, y))


def util(d, n):
	factors = set()
	for i in range(1, int(d ** 0.5) + 1):
		if d % i == 0:
			factors.add(i)
			factors.add(d // i)
	return [i for i in factors if d // i < n]

def process():
	(n, x, y) = map(int, input().split())
	d = y - x
	consider = sorted(util(d, n))
	diff = consider[0]
	middle = d // diff - 1
	seq = [x, y]
	n -= middle + 2
	for i in range(1, middle + 1):
		seq.append(x + i * diff)
	i = 1
	while n > 0:
		item = x - i * diff
		if item < 1:
			break
		seq.append(item)
		i += 1
		n -= 1
	i = 1
	while n > 0:
		item = y + i * diff
		seq.append(item)
		i += 1
		n -= 1
	print(*seq)
for i in range(int(input())):
	process()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	res = [1000000001] * n
	for start in range(1, 51):
		for diff in range(1, 51):
			a = []
			for ele in range(start, start + n * diff, diff):
				a.append(ele)
			if x in a and y in a and (res[n - 1] > a[n - 1]):
				res = a
	print(*res)


from sys import stdin

def inp():
	return stdin.buffer.readline().rstrip().decode('utf8')

def itg():
	return int(stdin.buffer.readline())

def mpint():
	return map(int, stdin.buffer.readline().split())
for __ in range(itg()):
	(n, x, y) = mpint()
	dis = y - x
	n -= 2
	ans = []
	(mx, kk) = (y + dis * n, dis)
	for k in range(1, dis + 1):
		if dis % k != 0:
			continue
		between = dis // k - 1
		between = max(between, 0)
		if between > n:
			continue
		left = x // k
		if x % k == 0:
			left -= 1
		left = min(n - between, left)
		if left + between == n:
			for _ in range(n + 2):
				ans.append(y)
				y -= k
			break
		right = n - left - between
		m = y + k * right
		if m < mx:
			(mx, kk) = (m, k)
	if not ans:
		for _ in range(n + 2):
			ans.append(mx)
			mx -= kk
	print(*ans)


import sys
import math
mod = 998244353
cases = True
dynamic_factorial = False

def main(test_case=False):
	n = int(input()) if test_case else 1
	for _ in range(n):
		test()

def fast_pow(a: int, b: int):
	res = 1
	while b > 0:
		if b & 1:
			res *= a
		a *= a
		b >>= 1
	return res

def c2(n):
	return n * (n - 1) // 2

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

def bits(n: int):
	return list(bin(n)).count('1')

def flush():
	sys.stdout.flush()

def parr(arr):
	print(*arr, sep=' ')

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

def ext_gcd(a: int, b: int):
	if b == 0:
		return [a, [1, 0]]
	res = ext_gcd(b, a % b)
	g = res[0]
	if g != 1:
		return False
	x1 = res[1][0]
	y1 = res[1][1]
	x = y1
	y = x1 - y1 * (a // b)
	return [g, [x, y]]

def get_set(a):
	res = {}
	for x in a:
		if x in res:
			res[x] += 1
		else:
			res[x] = 1
	return res
fact = {0: 1}

def factorial(n):
	if dynamic_factorial:
		if n not in fact:
			fact[n] = factorial(n - 1) * n
		return fact[n]
	else:
		res = 1
		while n > 0:
			res = res * n % mod
			n -= 1
		return res

def sum_of(a):
	res = 0
	for x in a:
		res = (res + x) % mod
	return res

def prod_of(a):
	res = 1
	for x in a:
		res = res * x % mod
	return res

def test():
	(n, x, y) = get()
	i = 0
	j = 0
	best_i = 0
	best_j = 0
	best_max = 999999999
	while i < n:
		j = i + 1
		while j < n:
			this_max = solve(n, x, y, i, j)
			if x - i * ((y - x) // (j - i)) <= 0 or (y - x) % (j - i) != 0:
				pass
			elif this_max < best_max:
				best_i = i
				best_j = j
				best_max = this_max
			j += 1
		i += 1
	parr(printarr(best_max, n, (y - x) // (best_j - best_i)))

def solve(n, x, y, i, j):
	return (n - 1 - j) * ((y - x) // (j - i)) + y

def printarr(max, n, d):
	a = []
	while len(a) < n:
		a.append(max)
		max -= d
	return a
main(cases)


t = int(input())
for _ipj_ in range(t):
	(n, x, y) = map(int, input().split())
	if n >= y:
		for i in range(1, n + 1):
			print(i, end=' ')
		print()
	else:
		tmp = y - x
		d = n - 1
		while tmp % d:
			d = d - 1
		dif = tmp // d
		a = y
		while a > 0:
			print(a, end=' ')
			n -= 1
			a -= dif
			if n <= 0:
				break
		a = y + dif
		while n > 0:
			print(a, end=' ')
			n -= 1
			a += dif


from collections import defaultdict as dd, deque
from sys import stdin
input = stdin.readline
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
		continue
	diff = y - x
	factors = [1]
	l = [x, y]
	if diff == 1:
		count = n - 2
		temp = x - 1
		while temp > 0 and count > 0:
			if temp > 0:
				l.append(temp)
				count -= 1
			temp -= 1
		if count:
			temp = y + 1
			while count:
				l.append(temp)
				temp += 1
				count -= 1
		print(*l)
		continue
	for i in range(2, 51):
		if diff % i == 0:
			factors.append(i)
	for i in range(len(factors)):
		noofval = (diff - factors[i]) // factors[i]
		if noofval > n - 2:
			continue
		else:
			temp = x + factors[i]
			count = n - 2
			while temp != y and count > 0:
				l.append(temp)
				count -= 1
				temp += factors[i]
			temp = x - factors[i]
			while temp > 0 and count > 0:
				if temp > 0:
					l.append(temp)
					count -= 1
				temp -= factors[i]
			if count:
				temp = y + factors[i]
				while count:
					l.append(temp)
					temp += factors[i]
					count -= 1
			if len(l) == n:
				break
	print(*l)


import sys, threading
from collections import defaultdict, Counter
input = sys.stdin.readline

def rl(type):
	return [type(w) for w in input().split()]

def reverse(arr):
	return arr[-1::-1]

def mod(a, m):
	return (a % m + m) % m

def create_graph(n):
	graph = {}
	for _ in range(n):
		(x, y) = map(int, input().split())
		graph[x].append(y)
		graph[y].append(x)
	return graph

def main():
	for _ in range(int(input())):
		(n, x, y) = map(int, input().split())
		drange = y - x
		gresult = [10 ** 10] * n
		for i in range(1, x + 1):
			for d in range(1, drange + 1):
				result = [i + k * d for k in range(n)]
				if x in result and y in result:
					gresult = result if max(result) < max(gresult) else gresult
					break
		print(' '.join((str(i) for i in gresult)))
sys.setrecursionlimit(10 ** 6)
threading.stack_size(10 ** 8)
t = threading.Thread(target=main)
t.start()
t.join()


for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = y - x
	for i in range(1, d + 1):
		if d % i:
			continue
		if d // i + 1 > n:
			continue
		k = min(n - 1, (y - 1) // i)
		a = y - k * i
		for j in range(n):
			print(a + j * i, end=' ')
		print()
		break


from sys import stdin

class Problem:

	def __init__(self, n, x, y):
		self.n = n
		self.x = x
		self.y = y

	def solve(self):
		minval = None
		maxval = None
		for parts in range(1, n):
			if (self.y - self.x) % parts != 0:
				continue
			w = (self.y - self.x) // parts
			b = min((y - 1) // w, n - 1)
			a = n - b
			if maxval == None or y + w * a < maxval:
				minval = y - w * b
				maxval = y + w * a
		w = (maxval - minval) // n
		return [minval + x * w for x in range(n)]
tc = int(stdin.readline())
for t in range(tc):
	(n, x, y) = map(int, stdin.readline().split())
	ans = Problem(n, x, y).solve()
	print(' '.join(map(str, ans)))


import sys
input = sys.stdin.readline
(inp, ip) = (lambda : int(input()), lambda : [int(w) for w in input().split()])
for _ in range(inp()):
	(n, x, y) = ip()
	ans = []
	mx = float('inf')
	for start in range(1, 51):
		for diff in range(1, 51):
			ap = [start + i for i in range(0, n * diff, diff)]
			if x in ap and y in ap and (ap[-1] < mx):
				ans = ap
				mx = ap[-1]
	print(*ans)


def find_ans(n, x, y):
	p = y - x
	for i in range(1, p + 1):
		if p % i == 0 and p / i + 1 <= n:
			break
	j = x
	while n > 0 and j <= y:
		print(j, end=' ')
		n -= 1
		j += i
	j = x - i
	while n > 0 and j > 0:
		print(j, end=' ')
		n -= 1
		j -= i
	j = y + i
	while n > 0:
		print(j, end=' ')
		n -= 1
		j += i
	print()
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	find_ans(n, x, y)


import math
t = int(input())
for _ in range(t):
	(n, x, y) = [int(i) for i in input().split()]
	lis = []
	for i in range(n - 1):
		for j in range(i + 1, n):
			if (y - x) % (j - i) != 0:
				continue
			else:
				c_d = (y - x) // (j - i)
				first = x - i * c_d
				t1 = []
				for k in range(n):
					t1.append(first + k * c_d)
					lis.append(t1)
	ma = 100000000000
	ans = []
	for i in range(len(lis)):
		if lis[i][-1] < ma and lis[i][0] > 0:
			ans = lis[i]
			ma = lis[i][-1]
	print(*ans)


t = int(input())
for _ in range(t):
	(n, x, y) = list(map(int, input().strip().split()))
	list1 = []
	for d in range(1, y - x + 1):
		if (y - x) % d == 0:
			terms = (y - x) // d + 1
			if terms <= n:
				for i in range(x, y + 1, d):
					n -= 1
					list1.append(i)
				for i in range(x - d, 0, -d):
					if n == 0:
						break
					n -= 1
					list1.append(i)
				for i in range(y + d, 10000, d):
					if n == 0:
						break
					n -= 1
					list1.append(i)
				break
	for val in list1:
		print(val, end=' ')
	print()


for _ in range(int(input())):
	(size, ak, at) = (int(x) for x in input().split())
	if size == 2:
		print(ak, end=' ')
		print(at)
	else:
		max_dif_a = size - 1
		d = 0
		dif_a = 0
		if ak < at:
			(ak, at) = (at, ak)
		for i in range(max_dif_a, 0, -1):
			if (ak - at) % i == 0:
				dif_a = i
				d = (ak - at) // i
				break
		ans = []
		while ak > 0 and len(ans) < size:
			ans.append(ak)
			ak -= d
		if len(ans) < size:
			i = 1
			while len(ans) != size:
				ans.append(ans[0] + i * d)
				i += 1
		ans.sort()
		print(*ans)


n = int(input())
for _ in range(n):
	(a, b, c) = map(int, input().split())
	d = 0
	for i in range(1, 51):
		for j in range(1, 51):
			lst = []
			k = 0
			for _ in range(a):
				lst.append(j + k)
				k += i
			if b in lst and c in lst:
				print(*lst)
				d = 1
				break
		if d == 1:
			break


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	if n == 2:
		print(a, b)
	else:
		d = b - a
		k = d
		f = n - 1
		while f > 0:
			if d % f == 0:
				k = d // f
				break
			f = f - 1
		l = []
		t = 0
		for i in range(a, b + 1, k):
			l.append(i)
			t = t + 1
		if a - k > 0:
			for i in range(a - k, 0, -k):
				if t == n:
					break
				l.append(i)
				t = t + 1
		x = 10 ** 9 + 1
		for i in range(b + k, x, k):
			if t == n:
				break
			l.append(i)
			t = t + 1
		print(*l)


z0s = int(input())
for t in range(z0s):
	(n, x, y) = map(int, input().split())
	arr = [x, y]
	a = y - x
	if n == 2:
		print(x, y)
	else:
		for i in range(n - 3, -2, -1):
			if a / (n - 2 - i) == a // (n - 2 - i):
				d = a // (n - 2 - i)
		for i in range(1, a // d):
			arr.append(x + i * d)
		if n - len(arr) > 0:
			for i in range(1, 10000001):
				if x - d * i >= 1:
					arr.append(x - d * i)
				else:
					break
				if n - len(arr) == 0:
					break
		if n - len(arr) > 0:
			for i in range(1, y + 100000):
				arr.append(y + d * i)
				if n - len(arr) == 0:
					break
		print(*arr)


t = int(input())
for i in range(t):
	(n, x, y) = input().split()
	(n, x, y) = (int(n), int(x), int(y))
	if (y - x) % (n - 1) == 0:
		k = (y - x) // (n - 1)
		a = [int(x + j * k) for j in range(n)]
	else:
		temp = n - 1
		while (y - x) % temp != 0:
			temp -= 1
		k = (y - x) // temp
		a = []
		for j in range((y - x) // k + 1):
			a.append(x + j * k)
		temp = n - ((y - x) // k + 1)
		while x - k > 0 and temp > 0:
			a.append(x - k)
			x -= k
			temp -= 1
		while temp > 0:
			a.append(y + k)
			y += k
			temp -= 1
	for c in a:
		print(c, end=' ')


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = y - x
	g = 1
	for i in range(n - 1, 0, -1):
		if d % i == 0:
			g = d // i
			break
	r = []
	f = 0
	v = y
	while len(r) < n and v > 0:
		r.append(v)
		v -= g
	v = y + g
	while len(r) < n:
		r.append(v)
		v += g
	print(*r)


def cal(n, x, y, d):
	n1 = (x - 1) // d
	n2 = (y - x) // d + 1
	if n2 > n:
		return 1 << 30
	if n1 + n2 >= n:
		return y
	n -= n1 + n2
	return y + n * d

def solve(x, d):
	for i in range(n):
		print(x, end=' ')
		x -= d
	print()
t = int(input())
for cas in range(t):
	(n, x, y) = map(int, input().split())
	d = y - x
	mn = 1 << 30
	for i in range(1, d + 1):
		if i * i > d:
			break
		if d % i != 0:
			continue
		mn = min(mn, cal(n, x, y, i), cal(n, x, y, d // i))
	for i in range(1, d + 1):
		if i * i > d:
			break
		if d % i != 0:
			continue
		if mn == cal(n, x, y, i):
			solve(mn, i)
			break
		elif mn == cal(n, x, y, d // i):
			solve(mn, d // i)
			break


for t in range(int(input())):
	(n, a, b) = map(int, input().split())
	d = b - a
	rama = []
	if d + 1 == n:
		for i in range(a, b + 1):
			print(i, end=' ')
		print()
		continue
	for i in range(1, 51):
		if d % i == 0 and d // i < n:
			break
	q = i
	count = 0
	i = a
	while i <= b:
		rama.append(i)
		i += q
		count += 1
	if n > count:
		i = a - q
		while i >= 1:
			if count == n:
				break
			rama.append(i)
			count += 1
			i -= q
		if n > count:
			i = b + q
			while count != n:
				rama.append(i)
				i += q
				count += 1
	for i in rama:
		print(i, end=' ')
	print()


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	m = 10 ** 10
	for i in range(1, min(a, b) + 1):
		for d in range(1, max(a, b) + 1):
			f = 0
			q = 0
			c = 0
			for k in range(i, max(a, b) + 1, d):
				c += 1
				if k == a:
					f = 1
				if k == b and f == 1 and (c <= n):
					q = 1
					break
			if f == 1 and q == 1:
				if i + (n - 1) * d < m:
					m = i + (n - 1) * d
					diff = d
					start = i
	for i in range(n):
		print(start, end=' ')
		start += diff
	print()


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	diff = abs(x - y)
	for i in range(1, abs(x - y) + 1):
		if abs(x - y) % i == 0 and abs(x - y) // i + 1 <= n:
			diff = i
			break
	ct = abs(x - y) // diff + 1
	ans = []
	for i in range(x, y + 1, diff):
		ans.append(i)
	for i in range(n - ct):
		x -= diff
		if x <= 0:
			break
		ct += 1
		ans.append(x)
	for i in range(n - ct):
		y += diff
		ct += 1
		ans.append(y)
	print(*ans)


k = int(input())
for _ in range(k):
	(n, x, y) = map(int, input().strip().split(' '))
	n -= 2
	d = 0
	for i in range(n + 1, 0, -1):
		if (y - x) % i == 0:
			d = (y - x) // i
			n -= i - 1
			break
	t = max(x - n * d, x % d if x % d > 0 else d)
	n -= (x - t) // d
	x = t
	y = y + n * d
	for i in range(x, y + 1, d):
		print(i, end=' ')
	print()


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	result = []
	l = [0] * n
	maxOverall = float('inf')
	for posX in range(n):
		l[posX] = x
		for interval in range(1, y - x + 1):
			cur = posX - 1
			while cur >= 0:
				l[cur] = l[cur + 1] - interval
				cur -= 1
			cur = posX + 1
			while cur < n:
				l[cur] = l[cur - 1] + interval
				cur += 1
			result.append(l[:])
			if max(l) >= y and min(l) > 0 and (y in l):
				maxOverall = min(maxOverall, max(l))
	for r in result:
		if max(r) == maxOverall and min(r) > 0 and (y in r):
			print(*r)
			break


def make_divisors(n):
	(lower, upper) = ([], [])
	i = 1
	while i * i <= n:
		if n % i == 0:
			lower.append(i)
			if i != n // i:
				upper.append(n // i)
		i += 1
	return lower + upper[::-1]
t = int(input())
ans = []
for _ in range(t):
	(n, x, y) = map(int, input().split())
	a = [num for num in make_divisors(y - x) if num <= n - 1][-1]
	d = (y - x) // a
	n -= 1
	temp = [y]
	while 0 < n and 0 < temp[-1] - d:
		temp.append(temp[-1] - d)
		n -= 1
	temp = sorted(temp)
	while 0 < n:
		temp.append(temp[-1] + d)
		n -= 1
	ans.append(temp)
for a in ans:
	print(*a)


from math import ceil, sqrt
t = int(input())

def fac(n):
	if n == 1:
		return [1]
	if n == 2:
		return [1, 2]
	facs = []
	for i in range(1, ceil(sqrt(n)) + 1):
		if n % i == 0:
			facs.append(i)
			if i != n // i:
				facs.append(n // i)
	return sorted(facs, reverse=True)
while t:
	(n, x, y) = [int(i) for i in input().split()]
	diff = y - x
	facs = fac(diff)
	maxi = float('inf')
	ans = diff // facs[0]
	for f in facs:
		done = f + 1
		if done > n:
			continue
		d = diff // f
		maxbef = x // d
		if x % d == 0:
			maxbef -= 1
		left = max(0, n - done - maxbef)
		if y + left * d <= maxi:
			ans = d
			maxi = y + left * d
	a = [maxi]
	for i in range(n - 1):
		a.append(a[-1] - ans)
	for ele in a:
		print(ele, end=' ')
	print()
	t -= 1


import sys
from math import ceil
fast_reader = sys.stdin.readline
fast_writer = sys.stdout.write

def input():
	return fast_reader().strip()

def print(*argv):
	fast_writer(' '.join((str(i) for i in argv)))
	fast_writer('\n')

def factors(a):
	ll = set()
	for i in range(1, a + 1):
		if a % i == 0:
			ll.add(i)
	return list(ll)
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	elif x == y - 1:
		if x - 1 >= n - 2:
			ans = []
			for i in range(y, y - n, -1):
				ans.append(i)
			print(*ans)
		else:
			ans = []
			for i in range(1, n + 1):
				ans.append(i)
			print(*ans)
	else:
		diff = y - x
		fact = factors(diff)
		fact.sort()
		ans = 2 ** 32
		lp = []
		for i in range(len(fact)):
			temp = n
			place = diff // fact[i] - 1
			if place + 2 == n:
				if y < ans:
					ans = y
					lp = []
					for j in range(x, y + 1, fact[i]):
						lp.append(j)
			elif place + 2 > n:
				continue
			else:
				pp = place + 2
				o = x
				while o - fact[i] > 0 and pp != n:
					o = o - fact[i]
					pp += 1
				if pp == n:
					if y < ans:
						ans = y
						lol = ans
						lp = []
						for j in range(n):
							lp.append(lol)
							lol -= fact[i]
				else:
					temp_arr = []
					lol = y
					for j in range(pp):
						temp_arr.append(lol)
						lol -= fact[i]
					lol = y
					while pp != n:
						lol += fact[i]
						pp += 1
						temp_arr.append(lol)
					my_ans = max(temp_arr)
					if my_ans < ans:
						ans = my_ans
						lp = temp_arr[:]
		print(*lp)


from math import ceil
from collections import deque
for _ in range(int(input())):
	(n, x, y) = [int(i) for i in input().split()]
	a = []
	j = 1
	while j <= y - x:
		if (y - x) % j == 0:
			a.append(j)
		j += 1
	d = y - x
	for i in a:
		if n > (y - x) // i:
			d = i
			break
	mn = max((x - 1) % d + 1, x % d - d * (n - (y - x) // i - 1), y - d * (n - 1))
	for i in range(n):
		print(mn, end=' ')
		mn += d
	print()


t = int(input())
h = 1
while h <= t:
	lis = list(map(int, input().split()))
	n = lis[0]
	x = lis[1]
	y = lis[2]
	mainlis = []
	maxi = 10000000
	if n == 2:
		print(x, end=' ')
		print(y)
	else:
		ar = [0 for i in range(n)]
		for i in range(0, n - 1):
			for j in range(i + 1, n):
				ar[i] = x
				ar[j] = y
				diff = j - i
				s = 0
				if (ar[i] - ar[j]) % diff == 0:
					d = (ar[j] - ar[i]) / diff
					for g in range(i + 1, n):
						ar[g] = ar[g - 1] + d
					for g in range(i - 1, -1, -1):
						if ar[g + 1] - d <= 0:
							s = 1
						else:
							ar[g] = ar[g + 1] - d
					if s == 0:
						if max(ar) < maxi:
							mainlis = []
							for q in ar:
								mainlis.append(int(q))
							maxi = max(ar)
		print(*mainlis)
	h += 1


def MD(x, n):
	md = 1
	for k in range(2, n):
		if x % k == 0:
			md = k
	return md
t = int(input())
for i in range(0, t):
	data = input().split()
	n = int(data[0])
	x = int(data[1])
	y = int(data[2])
	md = MD(y - x, n)
	delta = int((y - x) / md)
	inicial = y - delta * (n - 1)
	lista = [e for e in range(inicial, y + delta, delta)]
	for j in range(0, n - 1):
		print(lista[j] if lista[j] > 0 else y + delta * (j + 1), end=' ')
	print(lista[n - 1], end='\n')


import sys
ii = lambda : sys.stdin.readline().strip()
idata = lambda : [int(x) for x in ii().split()]

def solve():
	(n, a, b) = idata()
	n -= 2
	d = n + 1
	ans = []
	if not n:
		print(a, b)
		return
	while (b - a) % d:
		d -= 1
	d -= 1
	if d:
		ans = [a]
		c = (b - a) // (d + 1)
		for i in range(d):
			ans += [ans[-1] + c]
		ans = ans[1:]
	n -= d
	ans += [a]
	if not d:
		c = b - a
	while n:
		if ans[-1] - c <= 0:
			break
		ans += [ans[-1] - c]
		n -= 1
	ans += [b]
	while n:
		ans += [ans[-1] + c]
		n -= 1
	print(*sorted(ans))
	return
for t in range(int(ii())):
	solve()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	for i in range(n - 1, 0, -1):
		if (y - x) % i == 0:
			d = (y - x) // i
			terms_used = i
			break
	initial = (x - 1) // d
	arr = [x - initial * d + i * d for i in range(initial)] + [x + i * d for i in range(n)]
	if arr.index(y) <= n - 1:
		print(*arr[:n])
	else:
		ind = arr.index(y)
		print(*arr[ind - n + 1:ind + 1])


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = [0] * n
	mn = 9999999999999999999999999
	for i in range(n - 1):
		res = [0] * n
		res[i] = x
		for j in range(i + 1, n):
			if (y - x) % (j - i) == 0:
				res[j] = y
				ok = 1
				f = (y - x) // (j - i)
				for ii in range(i - 1, -1, -1):
					res[ii] = res[ii + 1] - f
				for jj in range(i + 1, n):
					res[jj] = res[jj - 1] + f
				if res[-1] < mn and res[0] > 0:
					mn = res[-1]
					ans = res
	print(*ans)


import math
t = int(input())
for _ in range(t):
	(n, x, y) = list(map(int, input().split()))
	ans = 100000000000000000000
	lmin = []
	for i in range(n - 1):
		for j in range(i + 1, n):
			ltemp = []
			d = y - x
			if d % (j - i) != 0:
				continue
			d = d // (j - i)
			an = x + (n - i - 1) * d
			ans = min(ans, an)
			if an == ans and an - (n - 1) * d > 0:
				ltemp = []
				for k in range(n):
					ltemp.append(an)
					an = an - d
				l = ltemp
	print(*l)


from sys import stdin
input = lambda : stdin.readline().strip()
import math
from collections import deque as d
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	cdiff = 100
	a = d([x])
	for i in range(1, n):
		if diff % i == 0:
			cdiff = diff // i
	f = 0
	for i in range(1, n):
		add = a[i - 1] + cdiff
		if add != y:
			a.append(add)
		else:
			a.append(add)
			f = n - i - 1
			break
	if f != 0:
		for i in range(f):
			sub = a[0] - cdiff
			if sub > 0:
				a.appendleft(sub)
			else:
				l = a.pop()
				a.append(l)
				a.append(l + cdiff)
	print(*a)


from collections import Counter
from collections import OrderedDict
from collections import defaultdict

def SOCountR(mylist):
	return OrderedDict(sorted(Counter(mylist).items(), reverse=True))

def SOCount(mylist):
	return OrderedDict(sorted(Counter(mylist).items()))

def freq_count(mylist):
	return Counter(mylist)
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	diff = y - x
	if diff < n:
		for i in range(x, y + 1):
			print(i, end=' ')
			n -= 1
		for i in range(x - 1, 0, -1):
			if n <= 0:
				break
			print(i, end=' ')
			n -= 1
		for i in range(y + 1, 10000000000):
			if n <= 0:
				break
			print(i, end=' ')
			n -= 1
		print()
	else:
		mul = 2
		while True:
			if diff % mul == 0:
				if diff // mul < n:
					break
			mul += 1
		for i in range(x, y + 1, mul):
			print(i, end=' ')
			n -= 1
		if n > 0:
			for i in range(x - mul, 0, -1 * mul):
				if n <= 0:
					break
				print(i, end=' ')
				n -= 1
		if n > 0:
			for i in range(y + mul, 10000000000, mul):
				if n <= 0:
					break
				print(i, end=' ')
				n -= 1
		print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	factors = []
	for i in range(1, diff + 1):
		if diff % i == 0:
			factors.append(i)
			factors.append(diff // i)
	best = None
	factors = sorted(list(set(factors)))
	for item in factors:
		if item + 1 <= n:
			best = item
	to_add = diff // best
	rn = x
	things = []
	while rn <= y:
		things.append(rn)
		rn += to_add
	if len(things) < n:
		others = []
		rn = things[0] - to_add
		k = len(things)
		while k < n and rn > 0:
			others.append(rn)
			rn -= to_add
			k += 1
		things = others[::-1] + things
	if len(things) < n:
		k = n - len(things)
		for _ in range(k):
			things.append(things[-1] + to_add)
	print(*things)


t = int(input())
for _ in range(t):
	inp = list(map(int, input().split()))
	n = inp[0]
	x = inp[1]
	y = inp[2]
	ans = 99999999999999999999
	for i in range(1, x + 1):
		for j in range(1, 51):
			if (x - i) % j == 0 and (y - i) % j == 0:
				a = (y - i) // j
				if a + 1 <= n:
					if i + (n - 1) * j < ans:
						ans = i + (n - 1) * j
						start = i
						diff = j
	for i in range(n):
		print(start + diff * i, end=' ')
	print(' ')


import sys
input = sys.stdin.readline
t = int(input())
for t1 in range(t):
	(n, x, y) = list(map(int, input().split(' ')))
	d = y - x
	arr = []
	f = 0
	for i in range(1, int(d ** 0.5) + 1):
		if d % i == 0:
			arr.append(i)
			arr.append(d // i)
			f = 1
	if f == 0:
		arr.append(d)
	f = []
	num = []
	z = 10 ** 9
	for j in range(len(arr)):
		d = arr[j]
		temp = []
		a = 1
		temp.append(x)
		for i in range(x + d, y + 1, d):
			temp.append(i)
			a += 1
		for i in range(x, 0, -d):
			if a == n:
				break
			if i == x:
				continue
			temp.append(i)
			a += 1
		if a <= n and x in temp and (y in temp):
			c = n - a
			start = y + d
			while True:
				if c == 0:
					break
				temp.append(start)
				c -= 1
				start += d
			f.append(temp)
			z = min(z, max(temp))
	for i in range(len(f)):
		if max(f[i]) == z:
			print(' '.join((str(x) for x in f[i])))
			break


t = int(input())
for _ in range(t):
	(n, x, y) = list(map(int, input().split()))
	mult = 1
	while ((n - 1) * mult < y - x or (y - x) % mult != 0) and mult <= y - x:
		mult += 1
	first_val = y % mult
	if first_val == 0:
		first_val += mult
	first_val = max(first_val, y - mult * (n - 1))
	print(' '.join((str(first_val + mult * i) for i in range(n))))


TC = int(input())
while TC > 0:
	(n, x, y) = list(map(int, input().split()))
	for diff in range(n - 1, 0, -1):
		if (y - x) % diff == 0:
			break
	diff = (y - x) // diff
	start = max(y - diff * (n - 1), (y - 1) % diff + 1)
	print(' '.join(map(str, range(start, start + n * diff, diff))))
	TC -= 1


import math
for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	subtract_value = 0
	for j in range(math.ceil((y - x) / (n - 1)), y - x + 1):
		if (y - x) % j == 0:
			subtract_value = j
			break
	result = [str(y - subtract_value * min(y // subtract_value, n - 1) + subtract_value * j) for j in range(n)]
	if result[0] == '0':
		result.append(str(int(result[-1]) + subtract_value))
		result.pop(0)
	print(' '.join(result))


def f(n):
	a1 = [1]
	for i in range(2, n):
		if n % i == 0:
			a1.append(i)
	return a1
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = [x, y]
	n -= 2
	if n == 0:
		print(*ans)
	else:
		t1 = f(y - x)
		temp = 0
		for i in t1:
			tp = (y - x) // i
			tp -= 1
			if tp <= n:
				temp = i
				break
		if temp == 0:
			temp = y - x
		ch = x + temp
		while ch < y and n > 0:
			ans.append(ch)
			ch += temp
			n -= 1
		ch = x - temp
		while ch > 0 and n > 0:
			ans.append(ch)
			ch -= temp
			n -= 1
		ch = y + temp
		while n > 0:
			ans.append(ch)
			ch += temp
			n -= 1
		print(*ans)


import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
import threading
from collections import defaultdict
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')
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = y - x - 1
	z = -1
	for i in range(d, -1, -1):
		if (d + 1) % (i + 1) == 0 and i <= n - 2:
			z = (d + 1) // (i + 1)
			break
	r = [x, y]
	ct = 2
	if z == -1:
		x = y - x
	for i in range(x + z, y, z):
		r.append(i)
		ct += 1
	for i in range(x - z, 0, -z):
		if ct == n:
			break
		r.append(i)
		ct += 1
	for i in range(y + z, 10 ** 5, z):
		if ct == n:
			break
		r.append(i)
		ct += 1
	print(*r)


from sys import stdin, stdout
input = stdin.readline
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	p = y - x - 1
	r = 1
	for i in range(n - 1):
		if p - i >= 0 and (p - i) % (i + 1) == 0:
			r = (p - i) // (i + 1)
			r += 1
	ans = [x, y]
	for i in range(x + r, y, r):
		if len(ans) == n:
			break
		ans.append(i)
	for i in range(x - r, 0, -r):
		if len(ans) == n:
			break
		ans.append(i)
	for i in range(y + r, 1000000, r):
		if len(ans) == n:
			break
		ans.append(i)
	print(*ans)


import math
import sys
input = sys.stdin.readline

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

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

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

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

def pbc(n, x, y):
	lst = []
	max = 10 ** 18
	for i in range(1, 51):
		for j in range(1, 51):
			temp = [i + j * d for d in range(n)]
			if x in temp and y in temp:
				if temp[-1] < max:
					max = temp[-1]
					lst = temp
	return lst
for i in range(inp()):
	(n, x, y) = invar()
	print(*pbc(n, x, y))


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	d = y - x
	F = set()
	for i in range(1, y):
		if d % i == 0:
			if d // i < n:
				F.add(i)
	(dif, ms, md) = (10201, n, 0)
	for i in F:
		(l, r) = ((x + i) // i, (y + i) // i)
		if r > n:
			ms = r
			dif = i
			md = x % i
		elif dif > i:
			dif = i
			md = (x - 1) % i + 1
	for i in range(ms, ms - n, -1):
		print((i - 1) * dif + md, end=' ' * (i + 1 != ms - n))
	print()


def solution(a, b, n):
	val = b - a
	p = n
	while val % (n - 1) != 0:
		n = n - 1
	d = val // (n - 1)
	arr = []
	q = p - n
	st = a
	while q > 0 and st > 0:
		st = st - d
		q = q - 1
	if st <= 0:
		st = st + d
	value = st
	for i in range(p):
		arr.append(value)
		value = value + d
	return arr
for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	arr = solution(a, b, n)
	print(*arr)


t = int(input())
for _ in range(t):
	(n, x, y) = [int(i) for i in input().split()]
	min_a0 = x
	min_d = y - x
	for a0 in range(1, x + 1):
		for d in range(1, 50):
			k = 0
			for i in range(n):
				ai = a0 + i * d
				if ai == x or ai == y:
					k += 1
			if k == 2 and min_a0 + min_d * (n - 1) > a0 + d * (n - 1):
				min_a0 = a0
				min_d = d
	print(' '.join([str(min_a0 + i * min_d) for i in range(n)]))


t = int(input())
while t > 0:
	t -= 1
	(n, a, b) = map(int, input().split())
	if n == 2:
		print(a, ' ', b)
		continue
	c = b - a
	f = 1
	while c / f > n - 1 or c % f > 0:
		f += 1
	ans = []
	at = a
	while at <= b:
		ans.append(at)
		at = at + f
		n -= 1
	at = a - f
	while n > 0 and at > 0:
		ans.append(at)
		at -= f
		n -= 1
	bt = b + f
	while n > 0:
		ans.append(bt)
		bt += f
		n -= 1
	print(*ans)


from fractions import gcd
from itertools import combinations, permutations, accumulate, product
from collections import deque, defaultdict, Counter
import decimal
import re
import math
import bisect
import sys
sys.setrecursionlimit(10000000)
mod = 10 ** 9 + 7
from sys import stdin
readline = stdin.readline

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

def readTuples():
	return tuple(map(int, readline().split()))

def I():
	return int(readline())

def yaku(m):
	ans = []
	i = 1
	while i * i <= m:
		if m % i == 0:
			j = m // i
			ans.append(i)
			if j != i:
				ans.append(j)
		i += 1
	ans = sorted(ans)
	return ans
for _ in range(I()):
	(n, x, y) = readInts()
	sa = y - x
	if n == 2:
		print(x, y)
		continue
	else:
		lis = yaku(sa)
		le = float('inf')
		ans = None
		for a in lis:
			quo = sa // a
			if quo > n - 1:
				continue
			else:
				l = sa // a
				l -= 1
				arr = [x, y]
				for i in range(l):
					arr.append(x + (i + 1) * a)
				nya = n - len(arr)
				small = x - 1
				small //= a
				pien = min(small, nya)
				for j in range(pien):
					arr.append(x - (j + 1) * a)
				nokori = nya - pien
				for k in range(nokori):
					arr.append(y + (k + 1) * a)
				if le > max(arr):
					le = max(arr)
					ans = arr
		ans = sorted(ans)
		print(*ans)


t = int(input())
while t > 0:
	(n, x, y) = map(int, input().split())
	i = 1
	s = set()
	s.add(x)
	l = []
	while not s.__contains__(y):
		ii = 1
		l = [x]
		m = x + i
		s = set()
		s.add(x)
		while ii < n:
			l.append(m)
			s.add(m)
			m += i
			ii += 1
		i += 1
	i -= 1
	while l[0] - 1 >= i and l[len(l) - 1] != y:
		j = 0
		while j < len(l):
			l[j] = l[j] - i
			j += 1
	for num in l:
		print(num, end=' ')
	print()
	t -= 1


import math
a = int(input())
for i in range(0, a):
	(n, x, y) = map(int, input().split())
	diff = -1
	for i in range(n - 1, 0, -1):
		if (y - x) % i == 0:
			diff = (y - x) // i
			break
	ans = []
	for i in range(n):
		ans.append(x + i * diff)
		if x + i * diff == y:
			break
	prev = []
	n = n - len(ans)
	while n > 0:
		if x - diff <= 0:
			break
		prev.append(x - diff)
		x = x - diff
		n = n - 1
	while n > 0:
		ans.append(ans[len(ans) - 1] + diff)
		n = n - 1
	for i in ans:
		prev.append(i)
	print(' '.join(map(str, prev)))


t = int(input())
while t:
	(l, a, b) = map(int, input().split())
	n = l - 1
	while (b - a) % n:
		n -= 1
	c = l - 1 - n
	p = (b - a) // n
	k = c * ((b - a) // n)
	arr = list(range(a, b + k + 1, (b - a) // n))
	arr1 = arr.copy()
	A = arr1[0]
	while A - p > 0 and arr1[-1] != b:
		arr1.insert(0, A - p)
		A -= p
		arr1.pop()
	print(*arr1)
	t -= 1


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	mxa = 0
	mxd = 0
	mx = 10 ** 12
	for a in range(1, 51):
		u = x - a
		v = y - a
		if u < 0:
			break
		for d in range(1, 51):
			if (v - u) % d == 0 and u % d == 0 and (a + (n - 1) * d >= y):
				if mx > a + (n - 1) * d:
					mx = a + (n - 1) * d
					mxa = a
					mxd = d
	print(*[mxa + mxd * i for i in range(n)])


from sys import stdin
N = int(stdin.readline())
for case in range(N):
	(count, start, end) = map(int, stdin.readline().split())
	if (end - start) % (count - 1) == 0:
		buf = (end - start) // (count - 1)
		for i in range(start, end + buf, buf):
			print(i, end=' ')
		print('\n')
	else:
		for i in range(count - 1, 1, -1):
			if (end - start) % (i - 1) == 0:
				buf = (end - start) // (i - 1)
				idx1 = 0
				idx2 = 1
				idx3 = 1
				for k in range(start, end + buf, buf):
					print(k, end=' ')
					idx1 += 1
				while idx1 < count and start - idx2 * buf > 0:
					print(start - idx2 * buf, end=' ')
					idx1 += 1
					idx2 += 1
				while idx1 < count:
					print(end + idx3 * buf, end=' ')
					idx1 += 1
					idx3 += 1
				print('\n')
				break


for t in range(int(input())):
	(n, x, y) = map(int, input().split(' '))
	r = (y - x) // (n - 1)
	if (y - x) % (n - 1) != 0:
		r += 1
	while r <= 50:
		if (y - x) % r == 0:
			break
		r += 1
	cnt = n - 1 - (y - x) // r
	l = (x - 1) // r
	l = min(cnt, l)
	cnt = cnt - min(cnt, l)
	st = x - r * l
	for i in range(st, st + n * r, r):
		print(i, end=' ')
	print()


from sys import stdin, stdout
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	for i in range(n - 1, 0, -1):
		if (y - x) % i == 0:
			delta = (y - x) // i
			break
	if x - x // delta * delta > 0:
		min = x - x // delta * delta
	else:
		min = x - (x // delta - 1) * delta
	for i in range(min, y, delta):
		if i + (n - 1) * delta >= y:
			x = i
			break
	for i in range(n):
		print(x + i * delta, end=' ')
	print()


t = int(input())
for _ in range(t):
	(n, a, b) = [int(i) for i in input().split(' ')]
	k = n - 1
	while (b - a) % k > 0:
		k -= 1
	p = []
	s = (b - a) // k
	curr1 = b
	curr2 = b + s
	for i in range(n):
		if curr1 > 0:
			p.append(curr1)
			curr1 -= s
		else:
			p.append(curr2)
			curr2 += s
	print(*p)


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	diff = y - x
	X = x
	res = 0
	count = 0
	for j in range(n - 1, 0, -1):
		if diff % j == 0:
			res = diff // j
			break
	while count != n and x <= y:
		print(x, end=' ')
		x = x + res
		count += 1
	X = X - res
	while count != n and X > 0:
		print(X, end=' ')
		X = X - res
		count += 1
	while count != n:
		y += res
		print(y, end=' ')
		count += 1
	print()


T = int(input())

def factors(n):
	a = [1]
	for i in range(2, n + 1):
		if n % i == 0:
			a.append(i)
	return a
for _ in range(T):
	(n, x, y) = [int(x) for x in input().split()]
	M = float('inf')
	super_ans = []
	for fct in factors(y - x):
		ns = fct + 1
		d = (y - x) // fct
		if ns <= n:
			extra = n - ns
			preceding = (x + d - 1) // d - 1
			if preceding >= extra:
				preceding = extra
				a0 = x - preceding * d
				ans = []
				for i in range(n):
					ans.append(a0)
					a0 += d
				super_ans = ans
				break
			else:
				exceeding = extra - preceding
				the_max = y + d * exceeding
				if the_max < M:
					M = the_max
					ans = []
					a0 = x - preceding * d
					for i in range(n):
						ans.append(a0)
						a0 += d
					super_ans = ans
	print(*super_ans)


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	flag = 0
	for i in range(n, 0, -1):
		for j in range(1, i):
			temp = (y - x) / (i - j)
			if temp.is_integer():
				flag = 1
				break
		if flag:
			break
	a = y - temp * (i - 1)
	while a <= 0:
		a += temp
	for k in range(1, n + 1):
		print(int(a + (k - 1) * temp), end=' ')
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n > y - x:
		d = 1
		if n >= y:
			(ll, ul) = (1, n)
		else:
			ll = y - n + 1
	else:
		dif = y - x
		if dif % (n - 1) == 0:
			(ll, d) = (x, dif // (n - 1))
		else:
			num = []
			for i in range(2, dif + 1):
				if dif % i == 0:
					num.append(i)
			f = 0
			for i in num:
				for q in range(1, x + 1):
					j = q
					if (x - j) // i == (x - j) / i and (y - j) // i == (y - j) / i:
						(o, p) = (0, 0)
						for k in range(n):
							if j == x:
								o = 1
							if j == y:
								p = 1
							j += i
						if o == 1 and p == 1:
							(ll, d) = (q, i)
							f = 1
							break
				if f == 1:
					break
	for i in range(n):
		print(ll, end=' ')
		ll += d
	print()


for _ in range(int(input())):
	(n1, x, y) = map(int, input().split())
	n = n1 - 1
	y1 = y
	while True:
		if (y - x) % n == 0:
			ans = (y - x) // n
			break
		else:
			n -= 1
	for i in range(n1):
		print(y, end=' ')
		y -= ans
		if y < 1:
			for j in range(n1 - i - 1):
				y1 += ans
				print(y1, end=' ')
			break
	print('')


import math
n = int(input())
for _ in range(n):
	(n, x, y) = map(int, input().split(' '))
	gap = y - x
	d = 1
	while d <= gap:
		(q, r) = divmod(gap, d)
		if r == 0 and q < n:
			e = x
			while e <= y:
				n -= 1
				print(e, end=' ')
				e += d
			e = x
			while n > 0 and e > d:
				n -= 1
				e -= d
				print(e, end=' ')
			e = y
			while n > 0:
				n -= 1
				e += d
				print(e, end=' ')
			break
		d += 1
	print('')


n = int(input())
sol = []
for i in range(n):
	maxs = []
	d = {}
	steps = []
	(l, x, y) = [int(c) for c in input().split()]
	if l == 2:
		sol.append([x, y])
		continue
	for j in range(1, l):
		s = abs(x - y) // j
		if s != 0:
			steps.append(s)
	for step in steps:
		for j in range(1, x + 1):
			a = [c for c in range(j, j + l * step, step)]
			if x in a and y in a:
				maxs.append(max(a))
				d[max(a)] = a
	sol.append(d[min(maxs)])
for s in sol:
	print(*s)


h = int(input())
l = []
for i in range(h):
	a = []
	(n, x, y) = list(map(int, input().split()))
	for i in range(1, y - x + 1):
		if (y - x) % i != 0:
			continue
		if n == (y - x) // i + 1:
			for j in range(x, y + 1, i):
				a.append(j)
			l.append(a)
			break
		elif n > (y - x) // i + 1:
			dn = n - ((y - x) // i + 1)
			if dn <= x // i:
				if x - i * dn > 0:
					for j in range(x - dn * i, y + 1, i):
						a.append(j)
					l.append(a)
					break
				else:
					for j in range(x - (dn - 1) * i, y + 1 + i, i):
						a.append(j)
					l.append(a)
					break
			else:
				ddn = dn - x // i
				if x - x // i * i > 0:
					for j in range(x - x // i * i, y + 1 + ddn * i, i):
						a.append(j)
					l.append(a)
					break
				else:
					for j in range(x - (x // i - 1) * i, y + 1 + (ddn + 1) * i, i):
						a.append(j)
					l.append(a)
					break
for a in l:
	print(*a)


for _ in range(int(input())):
	(n, a, l) = map(int, input().split())
	if n == 2:
		print(a, l)
	elif (l - a) % (n - 1) == 0:
		d = (l - a) // (n - 1)
		lst = list(range(a, l + 1, d))
		print(*lst)
	else:
		no = n
		while (l - a) % (n - 1) != 0:
			n = n - 1
		d = (l - a) // (n - 1)
		lst = list(range(a, l + 1, d))
		j = 1
		while a - j * d > 0 and n != no:
			lst.insert(0, a - j * d)
			j += 1
			n += 1
		j = 1
		while n != no:
			lst.append(l + j * d)
			j += 1
			n += 1
		print(*lst)


from math import inf
for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	diffs = [i for i in range(1, y - x + 1) if (x - y) % i == 0]
	ans = []
	minLast = inf
	for diff in diffs:
		elemsbwxy = (y - x) // diff + 1
		elemsbefx = (x - 1) // diff
		start = x - diff * elemsbefx
		arr = [i for i in range(start, y + diff, diff)]
		if len(arr) < n:
			at = y + diff
			while len(arr) != n:
				arr.append(at)
				at += diff
			if minLast > arr[-1]:
				minLast = arr[-1]
				ans = arr[:]
		elif x in arr[-n:]:
			minLast = y
			ans = arr[-n:]
	print(*ans)


for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	ans = [999999999]
	for s in range(1, 51):
		for d in range(51):
			a = [s]
			for i in range(1, n):
				a.append(a[i - 1] + d)
			if x in a and y in a:
				if a[-1] < ans[-1]:
					ans = a
	print(*ans)


t = int(input())
for f in range(t):
	nums = [int(i) for i in input().split()]
	n = nums[0]
	x = nums[1]
	y = nums[2]
	pos_answers = []
	pos_steps = []
	pos_starts = []
	for z in range(1, x + 1):
		for i in range(y):
			current = z
			check_box_1 = False
			check_box_2 = False
			steps = n
			if current == x:
				check_box_1 = True
			for j in range(n - 1):
				current += i
				if current == x:
					check_box_1 = True
				if current == y:
					check_box_2 = True
			if check_box_1 and check_box_2:
				pos_answers.append(current)
				pos_steps.append(i)
				pos_starts.append(z)
	min_index = pos_answers.index(min(pos_answers))
	for i in range(n):
		print(pos_starts[min_index] + i * pos_steps[min_index], end=' ')
	print()


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	i = -(-(y - x) // (n - 1))
	while (y - x) % i:
		i += 1
	bg = (x - 1) % i + 1
	while bg + i * (n - 1) < y:
		bg += i
	ans = ''
	for j in range(n):
		ans += str(bg + j * i) + ' '
	print(ans)


for _ in range(int(input())):
	(n, x, y) = [int(item) for item in input().split(' ')]
	diff = y - x
	step = -1
	for i in range(n - 1, 0, -1):
		if diff % i == 0:
			step = diff // i
			break
	res = []
	ptr = y
	while ptr > 0 and n > 0:
		res.append(ptr)
		(ptr, n) = (ptr - step, n - 1)
	ptr = y
	for i in range(n):
		ptr += step
		res.append(ptr)
	print(*res)


for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	result = [10 ** 10]
	for z in range(1, n):
		r = (y - x) / z
		if r != int(r):
			continue
		r = int(r)
		for p in range(n - z):
			arr_min = x - r * p
			if arr_min <= 0:
				arr_min = arr_min + r
				break
		array = [arr_min]
		for _ in range(n - 1):
			array.append(array[-1] + r)
		if array[-1] < result[-1]:
			result = array
	result_str = ' '.join(list(map(str, result)))
	print(result_str)


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	mins = []
	for i in reversed(range(1, n + 1)):
		if (y - x) % i:
			continue
		m = i
		d = (y - x) // m
		x0 = max(x % d + d * (x % d == 0), y - (n - 1) * d)
		if x0 > x:
			continue
		mins.append((x0 + (n - 1) * d, x0, d))
	m = min(mins, key=lambda x: x[0])
	for i in range(n):
		print(m[1] + m[2] * i, end=' ')
	print()


import math
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	mi = math.inf
	for i in range(n):
		for j in range(i + 1, n):
			arr = [-1] * n
			arr[i] = x
			f = 1
			arr[j] = y
			diff = (y - x) // (j - i)
			if (y - x) % (j - i) != 0:
				continue
			for m in range(i + 1, n):
				if arr[m] == -1:
					arr[m] = arr[m - 1] + diff
			for m in range(i - 1, -1, -1):
				if arr[m] == -1:
					arr[m] = arr[m + 1] - diff
			for m in range(n):
				if arr[m] <= 0:
					f = 0
					break
			if f:
				if arr[n - 1] < mi:
					mi = arr[n - 1]
					cu = arr
	print(*cu)


import collections
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		d = collections.deque()
		for j in range(n, 1, -1):
			(a, b) = divmod(y - x, j - 1)
			if b == 0:
				for i in range(x, y + 1, a):
					d.append(i)
				x -= a
				while len(d) < n and x >= 1:
					d.appendleft(x)
					x -= a
				while len(d) < n:
					y += a
					d.append(y)
				for i in d:
					print(i, end=' ')
				print()
				break


from sys import *
from math import *
from sys import stdin, stdout
from collections import *
int_arr = lambda : list(map(int, stdin.readline().strip().split()))
str_arr = lambda : list(map(str, stdin.readline().split()))
get_str = lambda : map(str, stdin.readline().strip().split())
get_int = lambda : map(int, stdin.readline().strip().split())
get_float = lambda : map(float, stdin.readline().strip().split())
mod = 1000000007
setrecursionlimit(1000)
lst = [i for i in range(1, 51)]
l = len(lst)

def ans(l, n, x, y, lst):
	for i in range(l):
		if (y - x) % lst[i] == 0 and (y - x) // lst[i] - 1 <= n - 2:
			val = lst[i]
			break
	res = [x, y]
	ct = 2
	(y1, x1) = (y, x)
	while ct != n:
		if y - val > x1:
			y -= val
			ct += 1
			res.append(y)
		elif x - val > 0:
			x -= val
			ct += 1
			res.append(x)
		else:
			y1 += val
			ct += 1
			res.append(y1)
	print(*res)
for _ in range(int(input())):
	(n, x, y) = get_int()
	ans(l, n, x, y, lst)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	x_c = x
	n_c = n
	y_c = y
	while (y - x) / (n - 1) != int((y - x) / (n - 1)):
		n -= 1
	a = int((y - x) / (n - 1))
	l = [x]
	while x != y:
		l.append(x + a)
		x += a
	if len(l) == n_c:
		print(*l)
	else:
		z = n_c - len(l)
		while z > 0:
			if x_c - a > 0:
				l.append(x_c - a)
				x_c -= a
			else:
				l.append(y_c + a)
				y_c += a
			z -= 1
		print(*l)


import math
t = int(input())
for _ in range(t):
	(n, a, b) = list(map(int, input().split(' ')))
	c = b - a
	d = 0
	flag = -1
	x1 = 0
	while flag != 1:
		for i in range(n - 1, 0, -1):
			for j in range(0, i):
				if c % (i - j) == 0:
					d = c // (i - j)
					x1 = b - i * d
					if x1 > 0:
						flag = 1
						break
					d = 0
			if d != 0:
				break
	for i in range(n):
		print(x1 + i * d, end=' ')
	print()


from typing import List, Dict
t = int(input())
prime = [2, 3, 5, 7, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

def ans_if_list(ans_list):
	return ' '.join((str(ans_list[i]) for i in range(len(ans_list))))

def subtract_common(ls: List, p_minimum, p_maximum, subtraction: int) -> Dict:
	res_ls = dict()
	count = 0
	while True:
		res = list()
		for i in ls:
			res.append(i - subtraction * count)
		if p_minimum - subtraction * count > 0:
			if p_minimum - subtraction * count + subtraction * len(ls) > p_maximum:
				res_ls[count] = res
			count += 1
		else:
			break
	return res_ls[list(res_ls.keys())[-1]]
for q in range(t):
	(n, x, y) = list(map(int, input().split()))
	if n == 2:
		ans = [x, y]
	else:
		ans_ele = 0
		diff = abs(x - y)
		poss = list()
		for i in range(1, diff + 1):
			if diff % i == 0:
				poss.append(i)
		for p in poss:
			if min(x, y) + n * p > max(x, y):
				ans_ele = p
				break
		ans = list([x + ans_ele * i for i in range(n)])
		ans = subtract_common(ans, min(x, y), max(x, y), ans_ele)
	print(ans_if_list(ans))


for t in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	if n == 2:
		print(x, y)
	else:
		t = n - 1
		while t > 0:
			if (y - x) % t == 0:
				break
			t -= 1
		step = (y - x) // t
		l = [x, y]
		t = x
		n -= 2
		while t + step < y:
			l.append(t + step)
			t += step
			n -= 1
		t = x
		while t - step > 0 and n > 0:
			l.append(t - step)
			t -= step
			n -= 1
		t = y
		while n > 0:
			l.append(t + step)
			t += step
			n -= 1
		for i in l:
			print(i, end=' ')
		print('\n')


for i in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	mi_diff = 0
	for j in range(1, n):
		tal = (y - x) / j
		if tal.is_integer():
			mi_diff = round(tal)
	tal = y
	n -= 1
	nums = [y]
	while tal > mi_diff and n > 0:
		n -= 1
		tal -= mi_diff
		nums.append(tal)
	if n == 0:
		print(' '.join((str(num) for num in nums)))
	else:
		while n > 0:
			n -= 1
			y += mi_diff
			nums.append(y)
		print(' '.join((str(num) for num in nums)))


for _ in range(int(input())):
	(n, x, y) = [int(i) for i in input().split()]
	bestelem = 1000000000.0 + 1
	bestfirst = 0
	bestd = 0
	for i in range(n - 1):
		for j in range(i + 1, n):
			if (y - x) % (j - i) != 0:
				continue
			else:
				d = (y - x) // (j - i)
				lastelem = y + (n - 1 - j) * d
				firstelem = x - i * d
				if lastelem < bestelem and firstelem >= 1:
					bestelem = lastelem
					bestfirst = firstelem
					bestd = d
	a = [0] * n
	a[0] = bestfirst
	for i in range(1, n):
		a[i] = a[i - 1] + bestd
	print(' '.join([str(i) for i in a]))


def f():
	t = int(input())
	arr = []
	for _ in range(t):
		arr.append(list(map(int, input().split())))
	for (n, x, y) in arr:
		if n == 2:
			print(f'{x} {y}')
			continue
		for d in range(1, y - x + 1):
			if (y - x) % d == 0 and (y - x) // d <= n - 1:
				i = y
				s = ''
				while n > 0 and i > 0:
					s += f' {i}'
					n -= 1
					i -= d
				i = y + d
				while n > 0:
					s += f' {i}'
					n -= 1
					i += d
				print(s[1:])
				break
f()


t = int(input())
while t:
	(n, x, y) = input().split(' ')
	n = int(n)
	x = int(x)
	y = int(y)
	t -= 1
	if n == 2:
		print(x, y)
	else:
		for gap in range(1, y - x + 1):
			m = (y - x) % gap
			p = int((y - x) / gap - 1)
			if m == 0 and p <= n - 2:
				q = int((x - 1) / gap)
				if q >= n - p - 2:
					s = gap
					end = y
				else:
					s = gap
					end = y + gap * (n - p - 2 - q)
				break
		l = []
		while end:
			l.append(end)
			end -= s
			if len(l) == n:
				break
		for i in range(len(l)):
			if i != 0:
				print(' ', end='')
			print(l[i], end='')
		print()


T = int(input())
for _ in range(T):
	(n, a, b) = map(int, input().split())
	f = 0
	for i in range(1, 51):
		for j in range(1, 51):
			l = []
			p = j
			for k in range(n):
				l.append(p)
				p += i
			if a in l and b in l:
				print(*l)
				f = 1
				break
		if f:
			break


def solve(n, x, y):
	if n == 2:
		return [x, y]
	max_ele_req = n - 2
	in_between_ele = y - x - 1
	for gap in range(1, y - x + 1):
		if (y - x) % gap != 0 or in_between_ele // gap > max_ele_req:
			continue
		if in_between_ele // gap == max_ele_req:
			return [val for val in range(x, y + 1, gap)]
		else:
			ele_rem = max_ele_req - in_between_ele // gap
			arr = []
			ele = x - gap
			while ele > 0 and ele_rem:
				arr.append(ele)
				ele -= gap
				ele_rem -= 1
			arr.reverse()
			arr.extend([val for val in range(x, y + 1, gap)])
			while ele_rem:
				arr.append(arr[-1] + gap)
				ele_rem -= 1
			return arr
t = int(input())
while t:
	(n_, x_, y_) = map(int, input().split(' '))
	print(*solve(n_, x_, y_))
	t -= 1


def prob3():
	t = int(input())
	for _ in range(t):
		(n, a, b) = list(map(int, input().split()))
		if n == 2:
			print(a, b)
			continue
		delta = n - 1
		while (b - a) % delta != 0:
			delta -= 1
		div = (b - a) / delta
		li = []
		count = n
		num = b
		while num > 0 and count > 0:
			li.append(int(num))
			num -= div
			count -= 1
		num = b + div
		while count > 0:
			li.append(int(num))
			count -= 1
			num += div
		print(*li)
prob3()


import math
t = int(input())
for _ in range(t):
	(n, x, y) = tuple([int(i) for i in input().split()])
	diff = y - x
	d = math.ceil(diff / (n - 1))
	while diff % d != 0:
		d += 1
	n -= diff // d - 1
	mini = x % d
	if mini == 0:
		mini = d
	_in = n
	n = max([n - (x - mini) // d, 2])
	mini = x - d * (_in - n)
	n -= 2
	print(' '.join([str(i) for i in list(range(mini, y + n * d + 1, d))]))


from sys import stdin, stdout
input = stdin.readline
print = lambda x: stdout.write(str(x) + '\n')
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	need = n - 2
	t = need
	while (y - x) % (t + 1):
		t -= 1
	diff = (y - x) // (t + 1)
	need -= t
	while need:
		if x - diff > 0:
			x -= diff
			need -= 1
		else:
			y += diff
			need -= 1
	ans = ' '.join([str(x + diff * i) for i in range(n)])
	print(ans)


for i in range(int(input())):
	(a, b, c) = [int(x) for x in input().split()]
	r = 0
	for j in range(a - 1, 0, -1):
		if (c - b) % j == 0:
			r = j
			break
	p = (c - b) // r
	k = a - r - 1
	while k != 0 and b > 0:
		b = b - p
		if b > 0:
			print(b, end=' ')
			k = k - 1
	h = c - p * r
	l = r + 1
	u = l + k
	while u != 0:
		print(h, end=' ')
		h = h + p
		u = u - 1
	print()


for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	coverable = y - x
	steps = []
	for i in range(1, coverable + 1):
		if coverable % i == 0 and coverable / i + 1 <= n:
			steps.append(i)
	step = min(steps)
	ans = []
	for i in range(x, y + 1, step):
		ans.append(i)
	to_add = n - len(ans)
	for i in range(1, to_add + 1):
		if x - step * i > 0:
			ans.append(x - step * i)
		else:
			break
	to_add = n - len(ans)
	for i in range(1, to_add + 1):
		ans.append(y + step * i)
	ans = list(map(str, ans))
	print(' '.join(ans))


import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from math import ceil

def main():

	def divisor(n):
		i = 1
		t = []
		while i * i <= n:
			if n % i == 0:
				t.append(i)
				t.append(n // i)
			i += 1
		t = list(set(t))
		t.sort()
		return t
	ti = int(input())
	for _ in range(ti):
		(n, x, y) = map(int, input().split())
		if n == 2:
			print(x, y)
		else:
			yx = y - x
			xydiv = divisor(yx)
			for d in xydiv:
				xyd = yx // d
				if n - 2 < xyd - 1:
					continue
				else:
					n2 = n - xyd - 1
					s = x
					while s > 0 and n2:
						s -= d
						n2 -= 1
					if s < 1:
						s += d
					for i1 in range(n):
						print(s + d * i1, end=' ')
					print('')
					break
main()


from functools import reduce
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import *
from io import BytesIO, IOBase
input = lambda : sys.stdin.readline().rstrip('\r\n')

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

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

def sarr():
	return [int(i) for i in input()]

def starr():
	return [str(x) for x in input().split()]

def inn():
	return int(input())

def svalue():
	return tuple(map(str, input().split()))

def parr():
	return [value() for i in range(n)]
mo = 1000000007
for _ in range(inn()):
	(n, x, y) = value()
	ans = []
	mx = 100000000000
	for i in range(1, 51):
		for j in range(1, 51):
			for k in range(1, 51):
				id = j
				l = []
				while id <= y:
					l += [id]
					id += k
				if x in l and y in l:
					if len(l) <= n and k < mx:
						ans = l[:]
						mx = k
	ln = n - len(ans)
	i = ans[-1]
	j = 0
	while j < ln:
		i += mx
		ans += [i]
		j += 1
	print(*ans)


import sys
input = sys.stdin.readline
read = lambda : map(int, input().split())

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

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

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

def nCr(n, k):
	if k > n:
		return 0
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0, hi=None):
	if hi == None:
		hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

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

def phi(n):
	result = n
	p = 2
	while p * p <= n:
		if n % p == 0:
			while n % p == 0:
				n = n // p
			result = result * (1.0 - 1.0 / float(p))
		p = p + 1
	if n > 1:
		result = result * (1.0 - 1.0 / float(n))
	return int(result)

def is_prime(n):
	if n == 0:
		return False
	if n == 1:
		return True
	for i in range(2, int(n ** (1 / 2)) + 1):
		if not n % i:
			return False
	return True
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

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

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

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

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
from itertools import permutations
import math
from bisect import bisect_left

def solve():
	(n, x, y) = read()
	gaps = y // n
	if gaps == 0:
		m = max(y, n)
		while n > 0:
			print(m, end=' ')
			n -= 1
			m -= 1
		print()
		return
	while (y - x) % gaps != 0:
		gaps -= 1
	if gaps * (n - 1) < y - x:
		gaps += 1
		while (y - x) % gaps != 0:
			gaps += 1
	ans = []
	for i in range(y, x - 1, -gaps):
		if len(ans) == n:
			break
		ans.append(i)
	for i in range(x - gaps, 0, -gaps):
		if len(ans) == n:
			break
		ans.append(i)
	while len(ans) < n:
		y += gaps
		ans.append(y)
	print(*ans)
for _ in range(int(input())):
	solve()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	z = y - x
	p = -1
	for i in range(1, z + 1):
		if z % i == 0 and z // i <= n - 1:
			p = i
			break
	i = 0
	k = 0
	while k + i < n:
		print(x + p * i, end=' ')
		i += 1
		if x + p * (i - 1) == y:
			k = 0
			while x - p * (k + 1) > 0 and k + i < n:
				print(x - p * (k + 1), end=' ')
				k += 1
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	for d in range(n - 1, 0, -1):
		if (y - x) % d == 0:
			break
	d = (y - x) // d
	start = max(y - (n - 1) * d, (y - 1) % d + 1)
	print(' '.join(map(str, [i for i in range(start, start + (n - 1) * d + 1, d)])))


from sys import stdin, stdout
q = int(input())
for i in range(q):
	(n, a, b) = list(map(int, stdin.readline().split()))
	if n == 2:
		print(a, b)
	else:
		d = b - a
		ind = 1
		flag = 0
		for i in range(n - 1, 0, -1):
			if d % i == 0:
				ind = i
				m = ind + 1
				diff = d // ind
				break
		f = n - m
		if ind == n - 1 or a - f * diff >= 1:
			start = a - f * diff
			for i in range(n):
				print(start, end=' ')
				start += diff
			print()
		else:
			start = a - diff
			x = 0
			while start > 1 and x <= n - ind:
				flag = 1
				start = start - diff
				x += 1
			if start < 1:
				start = start + diff
				for i in range(n):
					print(start, end=' ')
					start += diff
				print()
			else:
				for i in range(n):
					print(start, end=' ')
					start += diff
				print()


import io, os
inp = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
inar = lambda : list(map(int, inp().split()))
inin = lambda : int(inp())
inst = lambda : inp().decode().strip()

def all_factors(n):
	(small, large) = ([], [])
	for i in range(1, int(n ** 0.5) + 1, 2 if n & 1 else 1):
		if not n % i:
			small.append(i)
			large.append(n // i)
	if small[-1] == large[-1]:
		large.pop()
	large.reverse()
	small.extend(large)
	return small
_T_ = inin()
for _t_ in range(_T_):
	(n, x, y) = inar()
	a = all_factors(y - x)
	val = 0
	for i in a:
		if x + (n - 1) * i >= y:
			val = i
			break
	else:
		print('-1')
	ans = []
	count = 0
	next_ = y
	while next_ >= 1:
		ans.append(next_)
		next_ -= val
		count += 1
	next_ = y + val
	for i in range(max(0, n - len(ans))):
		ans.append(next_)
		next_ += val
	ans.sort()
	print(*ans[-n:])


n = int(input())
for i in range(n):
	(n, a, b) = map(int, input().split())
	c = b - a
	n -= 1
	i = 1
	m = []
	res = [a]
	while i * i <= c:
		if c % i == 0:
			m.append(i)
			m.append(c // i)
		i += 1
	m.sort(reverse=True)
	for i in m:
		if i <= n:
			c //= i
			break
	if n > i:
		while n > i and res[-1] - c > 0:
			res.append(res[-1] - c)
			n -= 1
	res.reverse()
	while n > 0:
		res.append(res[-1] + c)
		n -= 1
	print(*res)


from math import *
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	p = y - x
	for i in range(1, p + 1):
		if p % i == 0:
			r = p // i
			k = r + 1
			if n >= k:
				m = i
				break
	s = x
	for i in range(k):
		s = x + m * i
		print(s, end=' ')
	n = n - k
	s = x
	i = 1
	while s > 0 and n > 0:
		s = x - m * i
		if s > 0:
			print(s, end=' ')
		else:
			break
		n = n - 1
		if n == 0:
			break
		i = i + 1
	s = y
	i = 1
	while n > 0:
		s = y + m * i
		print(s, end=' ')
		n = n - 1
		if n == 0:
			break
		i = i + 1
	print()


for _ in range(int(input())):
	(n, x, y) = [int(i) for i in input().split()]
	d = y - x
	i = d // n + 1
	while d % i:
		i += 1
	x = max(x % i or i, y - n * i + i)
	print(*range(x, x + n * i, i))


def solve(n, x, y):
	temp = []
	for j in range(1, x + 1):
		diff = 1
		while True:
			if j + diff > y:
				break
			arr = []
			for k in range(n):
				arr.append(j + k * diff)
			if y in arr and x in arr:
				temp.append(arr)
				break
			else:
				diff += 1
	temp.sort(key=lambda x: x[-1])
	return temp[0]
t = int(input())
for i in range(t):
	(n, x, y) = [int(j) for j in input().split()]
	if n == 2:
		print(x, y)
	else:
		d = (y - x) / (n - 1)
		if d == int(d):
			for j in range(n):
				print(j * int(d) + x, end=' ')
			print()
		else:
			arr = solve(n, x, y)
			if arr != None:
				for k in arr:
					print(k, end=' ')
				print()


t = int(input())

def min_factor(a, n):
	i = 1
	while i <= a:
		if a % i == 0 and a // i + 1 <= n:
			return i
		i += 1
	return a
for _ in range(t):
	(n, x, y) = [int(i) for i in input().split(' ')]
	d = min_factor(y - x, n)
	res = [y]
	i = 1
	flag = False
	while i < n:
		if res[-1] - d > 0 and (not flag):
			res.append(res[-1] - d)
		elif not flag:
			flag = True
			res.append(y + d)
		else:
			res.append(res[-1] + d)
		i += 1
	print(' '.join(map(str, res)))


for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	if (y - x) % (n - 1) == 0:
		k = int((y - x) / (n - 1))
		print(*range(x, x + n * k, k))
	else:
		k = int((y - x) / (n - 1)) + 1
		while k <= y - x:
			if (y - x) % k == 0:
				break
			k = k + 1
		z = int((x - 1) / k)
		if n - 1 - (y - x) / k < z:
			print(*range(y - (n - 1) * k, y + k, k))
		else:
			print(*range(x - z * k, x + (n - z) * k, k))


import sys

def solve(n, x, y):
	diff = y - x
	smallest_max = float('inf')
	sm_gap = 0
	for n_between in range(n - 1):
		if diff % (n_between + 1) == 0:
			gap = diff // (n_between + 1)
			nleft = (x - 1) // gap
			nused = nleft + n_between + 2
			if nused >= n:
				smallest_max = y
				sm_gap = gap
			else:
				remain = n - nused
				smallest_max = y + remain * gap
				sm_gap = gap
		else:
			continue
	array = [x for x in range(smallest_max - (n - 1) * sm_gap, smallest_max + 1, sm_gap)]
	return array
IN = [x.strip() for x in sys.stdin.readlines()]
T = int(IN[0])
cur = 0
for ti in range(T):
	(n, x, y) = [int(x) for x in IN[cur + 1].split(' ')]
	res = solve(n, x, y)
	print(' '.join([str(x) for x in res]))
	cur += 1


t = int(input())
l = []
for i in range(t):
	(n1, x1, y1) = list(map(int, input().split()))
	l.append([n1, x1, y1])
for j in l:
	n = j[0]
	x = j[1]
	y = j[2]
	l1 = []
	for i in range(1, y - x + 1):
		if (y - x) % i == 0 and (y - x) // i <= n - 1:
			for p in range(y, 0, -i):
				l1.append(p)
				if len(l1) == n:
					break
			t = y + i
			while len(l1) != n:
				l1.append(t)
				t += i
			for q in l1:
				print(q, end=' ')
			print('')
			break


from math import *

def factors(n):
	fact = [1, n]
	for i in range(2, int(sqrt(n)) + 1):
		if n % i == 0:
			fact.append(i)
			if n // i != i:
				fact.append(n // i)
	return sorted(fact)
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	num = y - x
	fact = factors(num)
	flag = 0
	ans = []
	for i in fact:
		l = [x, y]
		terms = num // i - 1
		if terms > n - 2:
			continue
		elif terms == n - 2:
			for j in range(terms):
				l.append(l[-1] - i)
			flag = 1
			break
		else:
			c = n - 2
			a = y - i
			while a != x:
				l.append(a)
				a -= i
				c -= 1
			a -= i
			while c > 0 and a > 0:
				l.append(a)
				a -= i
				c -= 1
			if c > 0:
				a = y + i
				while c > 0:
					l.append(a)
					a += i
					c -= 1
			ans.append(l)
	if flag:
		print(*l)
	else:
		ans.sort(key=lambda x: max(x))
		print(*ans[0])


for _ in range(int(input())):
	(n, x, y) = [int(i) for i in input().split()]
	AL = [2 ** 32] * n
	for a in range(1, 51):
		for d in range(1, 51):
			l = a + (n - 1) * d
			AP = list(range(a, l + 1, d))
			if x in AP and y in AP and (AL[n - 1] > a + (n - 1) * d):
				AL = AP
	print(*AL)


import sys

def task():
	a1_res = 0
	d_res = 0
	(n, x, y) = map(int, input().split())
	p = y - x
	for d in range(1, p + 1):
		l = int(p / d)
		if l * d == p and l < n:
			a1 = y - (n - 1) * d
			if a1 <= 0:
				a1 = a1 + int((d - a1) / d) * d
			if a1_res == 0 or a1 + (n - 1) * d < a1_res + (n - 1) * d_res:
				a1_res = a1
				d_res = d
	return ' '.join(map(str, range(a1_res, a1_res + (n - 1) * d_res + 1, d_res)))
n = int(input())
for i in range(n):
	print(task())


import sys
import math

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

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

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

def SI():
	return sys.stdin.readline().strip()
t = II()
for q in range(t):
	(n, x, y) = MI()
	ans = -1
	for i in range(1, 50):
		a = [x]
		boo = False
		for j in range(n - 1):
			a.append(a[-1] + i)
			if a[-1] > y:
				break
			elif a[-1] == y:
				boo = True
				ans = i
		if boo:
			break
	a = [x]
	sec = []
	for i in range(n - 1):
		a.append(a[-1] + ans)
	a = a[:][::-1]
	for i in range(n):
		if a[i] == y:
			break
		if a[-1] - ans > 0:
			a.append(a[-1] - ans)
	a = a[:][::-1]
	print(*a[:n])


import math
lol = int(input())
for i in range(lol):
	nums = input().split(' ')
	n_orig = int(nums[0]) - 2
	n = [n_orig][0]
	x = int(nums[1])
	y = int(nums[2])
	ma = y
	count = 0
	diff = 0
	while True:
		if (y - x) % (n - count + 1) == 0:
			diff = (y - x) / (n - count + 1)
			n -= n - count
			break
		count += 1
	if n != 0:
		n -= min(math.floor((x - 1) / diff), n)
	lst = []
	for j in range(n_orig + 2):
		lst.insert(0, int(ma + diff * n - j * diff))
	print(*lst, sep=' ')


def factors(x):
	facs = []
	for i in range(1, x + 1):
		if x % i == 0:
			facs.append(i)
	return facs
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	dis = 1
	facs = factors(y - x)
	for i in range(len(facs)):
		if (y - x - 1) // facs[i] <= n - 2:
			dis = facs[i]
			break
	print(x, y, end=' ')
	i = 1
	while n - 2 > 0:
		if x + i * dis < y:
			n -= 1
			print(x + i * dis, end=' ')
			i += 1
		else:
			break
	i = 1
	while n - 2 > 0:
		if x - i * dis > 0:
			n -= 1
			print(x - i * dis, end=' ')
			i += 1
		else:
			break
	i = 1
	while n - 2 > 0:
		n -= 1
		print(y + i * dis, end=' ')
		i += 1
	print()


import sys
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n != 2:
		min_a = int(sys.float_info.max)
		min_l = int(sys.float_info.max)
		min_d = int(sys.float_info.max)
		for i in range(1, 51):
			for j in range(i + 1, 51):
				diff = (y - x) / (j - i)
				if diff % 1 == 0:
					first = y - (j - 1) * diff
					last = first + (n - 1) * diff
					if last < min_l and first > 0 and (last > 0):
						if y == first + (j - 1) * diff and x == first + (i - 1) * diff and (first <= x) and (y <= last):
							min_a = first
							min_l = last
							min_d = diff
		cnt = 0
		ans = []
		z = min_a
		while cnt < n:
			ans.append(int(z))
			z += min_d
			cnt += 1
		print(*ans)
	else:
		print(x, y)


q = int(input())
for x in range(q):
	(n, x, y) = map(int, input().split())
	lt = []
	i = n - 1
	d = 0
	while i != 0:
		if (y - x) % i == 0:
			d = (y - x) // i
			break
		else:
			i = i - 1
	print(x)
	j = 0
	ans = x
	while j < n - 1:
		ans = ans + d
		if ans == y:
			print(ans)
			j = j + 1
			break
		else:
			print(ans)
			j = j + 1
	ans = x
	while j < n - 1 and ans > 0 and (ans - d > 0):
		ans = ans - d
		print(ans)
		j = j + 1
	ans = y
	while j < n - 1:
		ans = ans + d
		print(ans)
		j = j + 1


t = int(input())
for _ in range(t):
	(n, x, y) = list(map(int, input().split(' ')))
	if n == 2:
		print(*[x, y])
	else:
		lst = [0] * n
		dif = y - x
		step = 0
		gap = 1
		for i in range(1, n):
			if dif % (n - i) == 0:
				step = dif // (n - i)
				gap = n - i
				break
		smallest = x
		for i in range(1, n - gap):
			if smallest <= step:
				break
			smallest -= step
		for i in range(n):
			print(smallest, end=' ')
			smallest += step
		print()


for tt in range(int(input())):
	(n, x, y) = map(int, input().split())
	found = False
	best = float('inf')
	for inc in range(1, y - x + 10):
		if found:
			break
		for start in range(1, 51):
			a = [start]
			g = False
			e = False
			for i in range(n):
				if a[-1] == x:
					g = True
				if a[-1] == y:
					e = True
				if i == n - 1:
					break
				a.append(a[-1] + inc)
			if e & g:
				if best > a[-1]:
					best = a[-1]
					ans = a
	print(*ans)


for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = [1000000000.0 for _ in range(n)]
	for i in range(n - 1, 0, -1):
		for j in range(i - 1, -1, -1):
			a = [0] * n
			diff = (y - x) // (i - j)
			a[i] = y
			a[j] = x
			if j:
				a[0] = x - j * diff
			for k in range(1, n):
				if k == i or k == j:
					continue
				a[k] = a[k - 1] + diff
			if max(ans) > max(a):
				check = False
				for l in range(n - 1):
					if a[l + 1] - a[l] != diff or a[l] <= 0 or a[l + 1] <= 0:
						check = True
						break
				if check:
					continue
				ans = [x for x in a]
	print(*ans)


import math
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = 10 ** 12
	for diff in range(1, 51):
		if (y - x) % diff == 0 and (y - x) // diff <= n - 1:
			for ini in range(1, 51):
				cnt = (y - x) // diff + 1
				cnt += (x - 1) // diff
				if cnt >= n:
					if ans > y:
						ans = min(ans, y)
						ind = diff
						k = ini
				elif ans > (n - cnt) * diff + y:
					ans = min(ans, (n - cnt) * diff + y)
					ind = diff
					k = ini
	for i in range(n):
		print(ans - i * ind, end=' ')
	print()


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	d = y - x
	for j in range(1, d + 1):
		if not d % j and d // j <= n - 1:
			k = j
			break
	a = d // k
	xk = 0
	while xk <= 0:
		xk = x - (n - a - 1) * k
		a += 1
	print(*(xk + k * j for j in range(n)))


import sys, math, cmath, time
start_time = time.time()

def solve():
	(n, x, y) = invr()
	q = y - x
	for i in range(1, q + 1):
		if q % i == 0 and q // i + 1 <= n:
			w = i
			break
	qq = x
	ww = n - q // w - 1
	while qq - w >= 1 and ww >= 1:
		qq = qq - w
		ww = ww - 1
	q = [qq]
	for i in range(n - 1):
		q.append(q[-1] + w)
	print(*q)

def main():
	global tt
	if not ONLINE_JUDGE:
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	t = 1
	t = inp()
	for tt in range(t):
		solve()
	if not ONLINE_JUDGE:
		print('Time Elapsed :', time.time() - start_time, 'seconds')
		sys.stdout.close()

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

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

def insr():
	return input().strip()

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

def counter(a):
	q = [0] * max(a)
	for i in range(len(a)):
		q[a[i] - 1] = q[a[i] - 1] + 1
	return q

def counter_elements(a):
	q = dict()
	for i in range(len(a)):
		if a[i] not in q:
			q[a[i]] = 0
		q[a[i]] = q[a[i]] + 1
	return q

def string_counter(a):
	q = [0] * 26
	for i in range(len(a)):
		q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
	return q

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

def prime_factors(n):
	q = []
	while n % 2 == 0:
		q.append(2)
		n = n // 2
	for i in range(3, int(n ** 0.5) + 1, 2):
		while n % i == 0:
			q.append(i)
			n = n // i
	if n > 2:
		q.append(n)
	return list(sorted(q))

def transpose(a):
	(n, m) = (len(a), len(a[0]))
	b = [[0] * n for i in range(m)]
	for i in range(m):
		for j in range(n):
			b[i][j] = a[j][i]
	return b

def factorial(n, m=1000000007):
	q = 1
	for i in range(n):
		q = q * (i + 1) % m
	return q
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
	input = sys.stdin.readline
main()


for p in range(int(input())):
	(n, a, b) = map(int, input().split())
	(s, c) = ([], n - 1)
	while (b - a) % c != 0:
		c -= 1
	(d, m) = ((b - a) // c, b)
	while n > 0 and m > 0:
		s.append(m)
		(n, m) = (n - 1, m - d)
	m = b
	while n > 0:
		(n, m) = (n - 1, m + d)
		s.append(m)
	s.sort()
	f = ''
	for i in range(len(s)):
		f += str(s[i]) + ' '
	print(f)


import math

def do(n, x, y):
	d = y - x
	if d == 0:
		print(' '.join((x for _ in range(n))))
	v = getV(d, n)
	myi = maxI(y, v)
	mxi = maxI(x, v)
	if mxi <= 0:
		myi -= mxi
	di = max(0, n - myi - 1)
	maxV = y + v * di
	if maxV - v * (n - 1) <= 0:
		maxV += v
	print(' '.join((str(maxV - v * i) for i in range(0, n))))

def getV(d, n):
	prev = 1
	for i in range(1, d + 1):
		if d / i <= n - 1:
			if int(d / i) == d / i:
				return i
	return prev

def maxI(x, v):
	return math.ceil((x - 1) / v)
t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	do(n, x, y)


def f(a):
	res = []
	for i in range(a, 0, -1):
		if a % i == 0:
			res.append(i)
	return res
t = int(input())
for _ in range(t):
	result = []
	(n, x, y) = map(int, input().split())
	factors = f(y - x)
	temp_i = False
	negative_key = True
	for i in factors:
		if x >= y - (n - 1) * i > 0:
			temp_i = i
			negative_key = False
			break
		if y - (n - 1) * i <= 0:
			temp_i = i
	if temp_i == False:
		start = x
		temp_i = y - x
	elif negative_key == False:
		start = y - (n - 1) * temp_i
	else:
		start = y - (y - y % temp_i)
		if start == 0:
			start = start + temp_i
	for j in range(n):
		result.append(start)
		start = start + temp_i
	print(*result)


import sys
stdin = sys.stdin
stdout = sys.stdout
test = int(stdin.readline())
for t in range(test):
	(n, x, y) = [int(_) for _ in stdin.readline().split()]
	sl = y - x
	required = n - 2
	fit = required
	while sl % (fit + 1) != 0:
		fit -= 1
	length = sl // (fit + 1)
	for i in range(x, y + length, length):
		stdout.write(f'{i} ')
	required -= fit
	for i in range(x - length, 0, -1 * length):
		if required == 0:
			break
		stdout.write(f'{i} ')
		required -= 1
	for i in range(y + length, 10 ** 9 + 1, length):
		if required == 0:
			break
		stdout.write(f'{i} ')
		required -= 1
	stdout.write('\n')


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	a = y - x
	A = []
	j = 1
	while j <= a:
		if a % j == 0:
			A.append(j)
		j += 1
	j = -1
	while j >= -len(A) and a // A[j] + 1 < n:
		j -= 1
	if j < -len(A):
		j = 0
	elif a // A[j] + 1 > n:
		j += 1
	k = n - a // A[j] - 1
	z = x // A[j]
	if x % A[j] == 0:
		z -= 1
	c = min(k, z)
	nach = x - c * A[j]
	s = 0
	while s < n:
		print(nach + s * A[j], end=' ')
		s += 1
	print()


from functools import reduce

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))))
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	Factors = factors(diff)
	Factors.sort()
	if n == 2:
		print(x, y)
	else:
		take = Factors[-1] - 1
		for i in range(1, len(Factors)):
			if Factors[i] - 1 > n - 2:
				take = Factors[i - 1] - 1
				break
		Ans = []
		inbet = int(diff / (take + 1))
		for i in range(x, y + 1, inbet):
			Ans.append(i)
		remain = n - len(Ans)
		First = []
		Num = x - inbet
		while Num > 0 and remain > 0:
			First.append(Num)
			Num -= inbet
			remain -= 1
		Second = []
		if remain:
			Num = y + inbet
			while remain > 0:
				Second.append(Num)
				Num += inbet
				remain -= 1
		real = []
		for i in First:
			real.append(i)
		for i in Ans:
			real.append(i)
		for i in Second:
			real.append(i)
		print(*real)


import os
import math
import sys
debug = True
if debug and os.path.exists('input.in'):
	input = open('input.in', 'r').readline
else:
	debug = False
	input = sys.stdin.readline

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

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

def insr():
	s = input()
	return s[:len(s) - 1]

def invr():
	return map(int, input().split())
test_count = inp()
for t in range(test_count):
	if debug:
		print('Test Case #', t + 1)
	(n, x, y) = invr()
	d = y - x
	div = max(1, math.ceil(d / (n - 1)))
	while True:
		if d % div == 0:
			break
		div += 1
	between = d // div
	total = between + 1
	start = x
	end = y
	if total < n:
		before = min(n - total, (start - 1) // div)
		start = start - before * div
		total += before
	if total < n:
		after = n - total
		end = y + div * after
	ans = []
	for i in range(n):
		ans.append(start + i * div)
	print(' '.join(map(str, ans)))


import math
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	ans = []
	for i in range(1, y - x + 1):
		if (y - x) % i == 0:
			if (y - x) // i >= n:
				continue
			t = y + i
			while n and y > 0:
				ans.append(y)
				n -= 1
				y -= i
			while n:
				ans.append(t)
				t += i
				n -= 1
			break
	print(' '.join(map(str, ans)))


R1 = lambda : list(map(int, input().split()))
R2 = lambda : int(input())
R3 = lambda : list(input())
t = R2()
for _ in range(t):
	(n, x, y) = R1()
	d = y - x
	k = d // n + 1
	while d % k:
		k += 1
	x = max(x % k or k, y - n * k + k)
	print(*range(x, x + n * k, k))


def main():
	t = int(input())
	for _ in range(t):
		(n, x, y) = map(int, input().split())
		ans = 10 ** 10
		dd = -1
		d = y - x
		for i in range(1, d + 1):
			if d % i != 0:
				continue
			cnt = d // i + 1
			if cnt > n:
				continue
			tmp = (x - 1) % i + 1
			ans_sub = max(y, tmp + i * (n - 1))
			if ans_sub < ans:
				ans = ans_sub
				dd = i
		lst = []
		for j in range(n):
			lst.append(ans)
			ans -= dd
		print(*lst)
main()


import os
from sys import stdin, stdout
from collections import deque

def solve(tc):
	(n, x, y) = map(int, stdin.readline().split())
	d = y - x
	if d < n:
		if y - n > 0:
			print(' '.join(map(lambda x: str(x), range(y - n + 1, y + 1))))
			return
		else:
			print(' '.join(map(lambda x: str(x), range(1, n + 1))))
			return
	p = 2
	picked = d
	while p * p <= d:
		if d % p == 0:
			if d // p + 1 <= n:
				picked = p
				break
			mod = d // p
			if mod != p and d // mod + 1 <= n:
				picked = min(picked, d // p)
		p += 1
	ans = deque(range(x, y + 1, picked))
	while len(ans) < n:
		if ans[0] - picked >= 1:
			ans.appendleft(ans[0] - picked)
		else:
			ans.append(ans[-1] + picked)
	print(' '.join(map(lambda x: str(x), ans)))
tcs = 1
tcs = int(stdin.readline().strip())
tc = 1
while tc <= tcs:
	solve(tc)
	tc += 1


import bisect
import copy
import fractions
import functools
import heapq
import math
import random
import sys
T = int(input())
for t in range(T):
	(N, X, Y) = tuple(map(int, input().split()))
	for div in range(1, Y - X + 1):
		if (Y - X) % div == 0 and div * (N - 1) >= Y - X:
			break
	max_ = Y
	n = N - math.ceil(Y / div)
	while n > 0:
		max_ += div
		n -= 1
	print(' '.join((str(max_ - i * div) for i in range(N))))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	p = n - 1
	count = 0
	while p != 1:
		if (y - x) % p == 0:
			break
		p = p - 1
	count = p + 1
	if x - (n - (p + 1)) * ((y - x) // p) > 0:
		z = x - (n - (p + 1)) * ((y - x) // p)
		for i in range(n):
			print(z, end=' ')
			z += (y - x) // p
	else:
		count = 0
		z = x - (y - x) // p
		while z > 0:
			print(z, end=' ')
			count += 1
			z -= (y - x) // p
		z = x
		for i in range(n - count):
			print(z, end=' ')
			z += (y - x) // p
	print()


import sys
input = sys.stdin.readline

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

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

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

def factors(n):
	if n == 1:
		return [1]
	v = [1]
	for i in range(2, n // 2 + 1):
		if n % i == 0:
			v.append(i)
	v.append(n)
	return v

def solve(n, x, y):
	if n == 2:
		return str(x) + ' ' + str(y)
	for factor in factors(y - x):
		if x + factor * (n - 1) < y:
			continue
		ans = [x, y]
		remaining = n - 2
		for i in range(1, n - 1):
			if x + i * factor >= y:
				break
			ans.append(x + i * factor)
			remaining -= 1
		for i in range(1, remaining + 1):
			if x - i * factor <= 0:
				break
			ans.append(x - i * factor)
			remaining -= 1
		for i in range(1, remaining + 1):
			ans.append(y + i * factor)
		return ' '.join(list(map(str, ans)))
lines = inp()
for i in range(lines):
	v = inlt()
	print(solve(*v))


import math

def fun(l, a, b):
	dif = b - a
	for i in range(l - 1, 0, -1):
		if dif % i == 0:
			d = dif / i
			break
	bw = dif / d + 1
	rem = l - bw
	k = math.ceil(a / d) - 1
	if rem <= k:
		mini = a - rem * d
		maxy = b
	else:
		mini = a - k * d
		rem2 = rem - k
		maxy = b + rem2 * d
	ans = []
	for j in range(l):
		ans.append(int(mini + j * d))
	return ans
n = int(input())
for _ in range(n):
	inp = input()
	(l, a, b) = (int(inp.split()[0]), int(inp.split()[1]), int(inp.split()[2]))
	lis = fun(l, a, b)
	for item in lis:
		print(item, end=' ')
	print('\n')


T = int(input())
for testcase in range(T):
	[n, x, y] = [int(i) for i in input().split()]
	possibled = range(1, 50)
	minmaximum = 100000
	mind = 0
	mina = 0
	for d in possibled:
		if (y - x) % d:
			continue
		if (y - x) // d > n - 1:
			continue
		if y > d * (n - 1):
			mind = d
			mina = y - d * (n - 1)
			minmaximum = y
		elif minmaximum > d * n + y % d:
			minmaximum = d * n + y % d
			mina = y % d
			if mina == 0:
				mina = d
			mind = d
	result = [str(mina + mind * i) for i in range(n)]
	print(' '.join(result))


def solve(n, x, y):
	ans = [10 ** 9 + 1] * n
	for a in range(1, 51):
		for d in range(1, 51):
			an = a + (n - 1) * d
			temp = []
			for i in range(a, an + 1, d):
				temp.append(i)
			if x in temp and y in temp and (temp[-1] < ans[-1]):
				ans = temp
	print(*ans)
	return
t = int(input())
while t != 0:
	(n, a, b) = map(int, input().split())
	solve(n, a, b)
	t -= 1


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	if n == 2:
		ans = [0 for _ in range(n)]
		ans[0] = x
		ans[1] = y
		print(*ans)
	else:
		pos = n - 1
		ans = [0 for _ in range(n)]
		best = 10000000000000000000
		while pos >= 1:
			for i in range(pos):
				if (y - x) % (pos - i) > 0:
					continue
				a = [0 for _ in range(n)]
				d = (y - x) // (pos - i)
				if x - d * i <= 0:
					continue
				for j in range(pos, n):
					a[j] = y + d * (j - pos)
				for j in range(i, -1, -1):
					a[j] = x - d * (i - j)
				for j in range(i, pos):
					a[j] = x + d * (j - i)
				if max(a) < best and min(a) > 0:
					best = max(a)
					for j in range(n):
						ans[j] = a[j]
			pos -= 1
		print(*ans)


def ans(n, x, y):
	candidates = set()
	for gap in range(n - 1, 0, -1):
		if (y - x) % gap == 0:
			diff = (y - x) // gap
			ret = [y]
			for _ in range(n - 1):
				ret += [ret[-1] - diff]
				if ret[-1] <= 0:
					ret = ret[:len(ret) - 1]
					break
			ret = sorted(ret)
			while len(ret) < n:
				ret += [ret[-1] + diff]
			candidates.add(tuple(ret)[::-1])
	print(*min(candidates))
T = int(input())
for t in range(T):
	(N, X, Y) = input().split()
	X = int(X)
	Y = int(Y)
	N = int(N)
	ans(N, X, Y)


from sys import stdin, stdout, setrecursionlimit
import heapq
from math import gcd, ceil, sqrt
from collections import Counter, deque
from bisect import bisect_left, bisect_right
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
setrecursionlimit(100000)
mod = 1000000007

def get(num, x, y, n):
	for i in range(1, 1000000):
		if y - n * i <= x and num % i == 0:
			return i
tc = ii1()
for _ in range(tc):
	(n, x, y) = iia()
	if n == 2:
		print(x, y)
	elif x - y + 2 == n:
		print(*list(range(x, y + 1)))
	else:
		diff = get(y - x, x, y, n - 1)
		arr = [y]
		cur = y
		flag = False
		while n - 1 > 0:
			if not flag and cur - diff > 0:
				arr.append(cur - diff)
				cur -= diff
			elif not flag:
				cur = y + diff
				arr.append(cur)
				flag = True
			elif flag:
				arr.append(cur + diff)
				cur += diff
			n -= 1
		print(*sorted(arr))


for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
		continue
	val = y - x
	ans = 1
	for i in range(n - 1, 0, -1):
		if val % i == 0:
			ans = val // i
			break
	out = [i for i in range(x, y + 1, ans)]
	left = x - ans
	right = y + ans
	while len(out) < n:
		if left >= 1:
			out.append(left)
			left -= ans
		else:
			out.append(right)
			right += ans
	print(*out)


t = int(input())
for _ in range(t):
	s = list(map(int, input().split()))
	n = s[0]
	x = s[1]
	y = s[2]
	i = n - 1
	d = 0
	while i > 0:
		if (y - x) % i == 0:
			d = (y - x) // i
			break
		i -= 1
	q = x - d * min(x // d, n - 1 - i)
	if q == 0:
		q += d
	for j in range(n):
		print(q + j * d, end=' ')
	print()


for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	for i in range(n, 0, -1):
		d = (y - x) / (i - 1)
		if d == int(d):
			d = int(d)
			break
	a_0 = x
	while a_0 > 0:
		a_0 -= d
		if a_0 + (n - 1) * d < y:
			a_0 += d
			break
	if a_0 <= 0:
		a_0 += d
	for i in range(n):
		print(a_0 + i * d, end=' ')
	print()


def divisors(n):
	a = []
	for i in range(1, n + 1):
		if n % i == 0:
			a.append(i)
	return a
F = [None] * 51
for i in range(1, 51):
	F[i] = divisors(i)

def cal(n, x, y, t):
	if (y - x) / t > n - 1:
		return
	start = x % t
	if start == 0:
		start += t
	if (n - 1) * t >= y:
		return start
	else:
		return y - (n - 1) * t

def solve(n, x, y):
	(end, start, t) = (9999999, 0, 0)
	global F
	for i in F[y - x]:
		s = cal(n, x, y, i)
		if s is None:
			continue
		elif s + (n - 1) * i < end:
			end = s + (n - 1) * i
			start = s
			t = i
	return (start, end, t)
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split(' '))
	(start, end, t) = solve(n, x, y)
	for i in range(start, end + t, t):
		print(i, end=' ')
	print('')


t = int(input())
for i in range(t):
	arr = list(map(int, input().rstrip().split()))
	n = arr[0]
	x = arr[1]
	y = arr[2]
	if n == 2:
		array = [x, y]
		print(' '.join(map(str, array)))
	else:
		for i in range(n - 1, 0, -1):
			if (y - x) % i == 0:
				diff = (y - x) // i
				break
		if y - diff * (n - 1) > 0:
			s = y - diff * (n - 1)
			array = [s]
			for i in range(1, n):
				array += [s + i * diff]
			print(' '.join(map(str, array)))
		elif y % diff == 0:
			array = [diff]
			for i in range(1, n):
				array += [diff * (1 + i)]
			print(' '.join(map(str, array)))
		else:
			s = y % diff
			array = [s]
			for i in range(1, n):
				array += [s + i * diff]
			print(' '.join(map(str, array)))


import math
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	kd = y - x
	ans = None
	f = None
	for i in range(1, kd + 1):
		if kd % i == 0:
			if (kd + i) // i <= n:
				r = (y - x) // i + 1
				bx = (x - 1 + i) // i - 1
				if ans == None:
					if r + bx >= n:
						ans = y
						f = i
					else:
						et = n - bx - r
						ans = y + et * i
						f = i
				elif r + bx >= n:
					if ans > y:
						f = i
						ans = y
				else:
					et = n - bx - r
					if ans > y + et * i:
						ans = y + et * i
						f = i
	print(*(ans - f * g for g in range(n)))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	r = y - x
	o = y
	d = 1
	for i in range(n - 1, 0, -1):
		if r % i == 0:
			d = r // i
			break
	print(o, end=' ')
	for _ in range(n - 1):
		if o - d > 0:
			print(o - d, end=' ')
			o = o - d
		else:
			y = y + d
			print(y, end=' ')
	print()


import sys

def solve(n, x, y):
	mn = pow(10, 9) + 10
	Dif = 0
	ans_arr = [1] * n
	for a in range(n):
		for b in range(a + 1, n):
			N = b - a + 1
			if (y - x) % (N - 1) != 0:
				continue
			D = (y - x) // (N - 1)
			if x - a * D > 0:
				A = x - a * D
				tmp = A + (n - 1) * D
				if tmp < mn:
					mn = tmp
					Dif = D
	ans_arr[-1] = mn
	for p in range(n - 2, -1, -1):
		ans_arr[p] = ans_arr[p + 1] - Dif
	for q in range(n):
		ans_arr[q] = str(ans_arr[q])
	return ans_arr
t = int(sys.stdin.readline())
for i in range(t):
	[n, x, y] = [int(j) for j in sys.stdin.readline().split()]
	print(' '.join(solve(n, x, y)))


import math

def primeFactors(n, p):
	i = 1
	while True:
		if p % i == 0 and p // i + 1 <= n:
			return i
		i += 1
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	p = y - x
	i = primeFactors(n, p)
	if p % i + 1 < n:
		ycop = y
		n -= 2
		print(x, y, end=' ')
		while n >= 0:
			if y - i <= 0:
				y = ycop + i
				i = -i
			else:
				y -= i
			if y != x:
				print(y, end=' ')
			n = n - 1
		print('')


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	n -= 2
	if n == 0:
		print(x, y, end='')
	elif y - x - 1 <= n:
		n -= y - x - 1
		a = min(x - 1, n)
		n -= a
		for i in range(x - a, y + n + 1):
			print(i, end=' ')
	else:
		d = 2
		while (y - x) % d != 0 or (y - x) // d - 1 > n:
			d += 1
		b = (y - x) // d - 1
		n -= b
		if x % d == 0:
			a = min(x // d - 1, n)
		else:
			a = min(x // d, n)
		n -= a
		for i in range(x - a * d, y + n * d + 1, d):
			print(i, end=' ')
	print()


import math
ceil = math.ceil
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	if True:
		for j in range(0, n - 1):
			i = n - j - 1
			if not (y - x) % i:
				gap = (y - x) // i
				between_X_Y = i
				below_X = min(n - i, x // gap + bool(x % gap))
				above_Y = n - below_X - between_X_Y
				lowest = [x - gap * l for l in range(0, below_X)]
				middle = [x + gap * (l + 1) for l in range(0, between_X_Y)]
				highest = [y + gap * (l + 1) for l in range(0, above_Y)]
				ans = lowest + middle + highest
				print(*ans)
				break


m = int(input())
for i in range(m):
	(n, x, y) = map(int, input().split(' '))
	kk = 1
	while (n - 1) * kk < y - x or (y - x) % kk:
		kk += 1
	a1 = max((y - 1) % kk + 1, y - (n - 1) * kk)
	print(*(a1 + kk * i for i in range(n)))


for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = []
	if y - x + 1 == n:
		for i in range(x, y + 1):
			ans += [i]
		print(*ans)
	elif y - x + 1 < n:
		tmp = n - y + x - 1
		for i in range(x, y + 1):
			ans += [i]
		i = x - 1
		while i > 0 and tmp:
			ans += [i]
			i -= 1
			tmp -= 1
		i = y + 1
		while tmp:
			ans += [i]
			i += 1
			tmp -= 1
		print(*ans)
	elif n == 2:
		print(x, y)
	elif (y - x) % (n - 1) == 0:
		ans = [x, y]
		turn = (y - x) // (n - 1)
		i = x + turn
		while i < y:
			ans += [i]
			i += turn
		print(*ans)
	else:
		g = y - x
		j = 1
		while j <= g:
			if g % j == 0 and g // j <= n - 2:
				break
			j += 1
		turn = j
		tmp = n - 2
		ans = [x, y]
		i = x + turn
		while i < y and tmp:
			ans += [i]
			i += turn
			tmp -= 1
		i = x - turn
		while i > 0 and tmp:
			ans += [i]
			i -= turn
			tmp -= 1
		i = y + turn
		while tmp:
			ans += [i]
			i += turn
			tmp -= 1
		print(*ans)


def solve(n, x, y):
	res = [float('inf')] * n
	for i in range(1, 51):
		for j in range(1, 51):
			arr = [i + k * j for k in range(n)]
			if x in arr and y in arr and (arr[-1] < res[-1]):
				res = arr.copy()
	print(*res)
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	solve(n, x, y)


import sys, math
try:
	(sys.stdin, sys.stdout) = (open('input.txt', 'r'), open('out.txt', 'w'))
except:
	pass
from sys import stdin, stdout
mod = int(1000000000.0 + 7)
from statistics import mode
from collections import *
from math import ceil, floor, inf, factorial, gcd, log2, sqrt, log
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()

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

def setbits(n):
	return bin(n).count('1')

def resetbits(n):
	return bin(n).count('0')

def modinv(n, p):
	return pow(n, p - 2, p)

def ncr(n, r):
	(num, den) = (1, 1)
	r = min(n, n - r)
	for i in range(r):
		num *= n - i
		den *= i + 1
	return num // den

def ncr_p(n, r, p):
	(num, den) = (1, 1)
	r = min(r, n - r)
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * modinv(den, p) % p

def isPrime(num):
	if num <= 1:
		return False
	if num == 2 or n == 3:
		return True
	if num % 2 == 0 or num % 3 == 0:
		return False
	m = int(num ** 0.5) + 1
	for i in range(5, m, 6):
		if num % i == 0 or num % (i + 2) == 0:
			return False
	return True

def bin_search(s, low, high, val):
	while low <= high:
		mid = low + (high - low) // 2
		if s[mid] == val:
			return mid
		elif s[mid] < val:
			low = mid + 1
		else:
			high = mid - 1
	return -1

def sumofdigit(num):
	count = 0
	while num:
		count += num % 10
		num //= 10
	return count

def inputmatrix():
	(r, c) = iia()
	mat = [0] * r
	for i in range(r):
		mat[i] = iia()
	return (r, c, mat)

def prefix_sum(n, s):
	for i in range(1, n):
		s[i] += s[i - 1]
	return s

def binomial(n, k):
	if 0 <= k <= n:
		ntok = 1
		ktok = 1
		for t in range(1, min(k, n - k) + 1):
			ntok *= n
			ktok *= t
			n -= 1
		return ntok // ktok
	else:
		return 0

def divisors(n):
	res = []
	for i in range(1, ceil(sqrt(n)) + 1):
		if n % i == 0:
			if i == n // i:
				res.append(i)
			else:
				res.append(i)
				res.append(n // i)
	return res
for _ in range(ii1()):
	(n, a, b) = iia()
	B = b
	diff = b - a
	arr = divisors(diff)
	arr.sort()
	l = len(arr)
	ans = [a, b]
	m = n - 2
	for i in range(l):
		if diff // arr[i] <= m + 1:
			diff = arr[i]
			break
	m = n - len(ans)
	for i in range(m):
		if b - diff == a:
			b -= diff
			if b - diff > 0:
				ans.append(b - diff)
				b -= diff
			else:
				break
		elif b - diff > 0:
			ans.append(b - diff)
			b -= diff
		else:
			break
	m = n - len(ans)
	for i in range(m):
		B += diff
		ans.append(B)
	ans.sort()
	print(*ans)


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')
from math import gcd, ceil

def pre(s):
	n = len(s)
	pi = [0] * n
	for i in range(1, n):
		j = pi[i - 1]
		while j and s[i] != s[j]:
			j = pi[j - 1]
		if s[i] == s[j]:
			j += 1
		pi[i] = j
	return pi

def prod(a):
	ans = 1
	for each in a:
		ans = ans * each
	return ans

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

def binary(x, length=16):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y
for _ in range(int(input()) if True else 1):
	(n, x, y) = map(int, input().split())
	diff = y - x
	from math import inf
	ans = inf
	di = {}
	for i in range(1, diff + 1):
		if diff % i:
			continue
		count = 1
		f = x
		a = [x]
		while 1:
			f += i
			a += [f]
			count += 1
			if f == y:
				break
		if count > n:
			continue
		f = x
		while 1:
			if count >= n:
				break
			f -= i
			if f < 1:
				break
			a = [f] + a
			count += 1
		if count >= n:
			ans = min(ans, y)
			di[y] = a
		else:
			for j in range(n - count):
				a += [y + i * (j + 1)]
			ans = min(ans, y + diff * (n - count))
			di[y + diff * (n - count)] = a
	print(*di[ans])


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	temp = n - 1
	f = 0
	while temp > 0:
		if (y - x) % temp == 0:
			f = 1
			break
		temp -= 1
	d = 0
	c = 0
	a = []
	if f:
		d = abs((y - x) // temp)
		c = 0
		for i in range(x, y + 1, d):
			a.append(i)
			c += 1
		q = x - d
		while q > 0 and c < n:
			a.append(q)
			c += 1
			q -= d
		p = y + d
		for i in range(n - c):
			a.append(p)
			p += d
		print(*a)
	else:
		c = 2
		d = n
		q = x - d
		a.append(x)
		a.append(y)
		while q > 0 and c < n:
			a.append(q)
			c += 1
			q -= d
		p = y + d
		for i in range(n - c):
			a.append(p)
			p += d
		print(*a)


def input_int():
	return int(input())

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

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

def run():
	q_num = input_int()
	for i in range(q_num):
		(num_count, first_num, second_num) = input_input_map()
		diff_num = second_num - first_num
		one_step_num = diff_num
		for num in range(1, diff_num // 2 + 1):
			if diff_num % num == 0 and diff_num / num < num_count:
				one_step_num = num
				break
		total_diff = one_step_num * (num_count - 1)
		if second_num - total_diff < 1:
			diff_count = second_num // one_step_num
			if second_num - one_step_num * diff_count == 0:
				start = second_num - one_step_num * (diff_count - 1)
			else:
				start = second_num - one_step_num * diff_count
		else:
			start = second_num - total_diff
		results = []
		for j in range(num_count):
			results.append(start + one_step_num * j)
		print(' '.join(map(str, results)))
run()


t = int(input())
for k in range(0, t, 1):
	(n, x, y) = map(int, input().split())
	a = []
	for i in range(n, 0, -1):
		if (y - x) % (i - 1) == 0:
			n1 = 1
			n2 = i
			break
	d = int((y - x) / (n2 - n1))
	count = 0
	z = 0
	for i in range(x, y + 1, d):
		a.append(i)
		count += 1
		if count == n:
			z = 1
			break
	if z == 0:
		for i in range(x - d, 0, -d):
			a.append(i)
			count += 1
			if count == n:
				z = 1
				break
	if z == 0:
		for i in range(y + d, 10000000, d):
			a.append(i)
			count += 1
			if count == n:
				z = 1
				break
	a.sort()
	for i in range(0, n, 1):
		print(a[i], end=' ')
	print('')


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

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

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

def outa(*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)]

def calc(value):
	temp = []
	for i in range(x, y + 1, value):
		temp.append(i)
	if len(temp) < n:
		for i in range(x - value, 0, -value):
			temp.append(i)
			if len(temp) == n:
				break
	if len(temp) < n:
		i = y + value
		while len(temp) < n:
			temp.append(i)
			i += value
	if len(temp) != n:
		return False
	return temp
for _ in range(int(data())):
	(n, x, y) = sp()
	answer = [0] * n
	best = 10 ** 10
	diff = y - x
	factors = set()
	j = 1
	while j * j <= diff:
		if diff % j == 0:
			new = calc(j)
			if new and max(new) < best:
				answer = new[:]
				best = max(new)
			if j != diff // j:
				new = calc(diff // j)
				if new and max(new) < best:
					answer = new[:]
					best = max(new)
		j += 1
	outa(*answer)


t = int(input())
for _ in range(0, t):
	inputs = [int(num) for num in input().split()]
	n = inputs[0]
	x = inputs[1]
	y = inputs[2]
	start = n - 1
	i = start
	while (y - x) / i != (y - x) // i:
		i -= 1
	cd = (y - x) // i
	vals = i + 1
	min1 = x
	max1 = y
	if vals < n:
		min1 = x
		while min1 - cd > 0 and vals < n:
			min1 = min1 - cd
			vals += 1
	if vals < n:
		max1 = y
		while vals < n:
			max1 = max1 + cd
			vals += 1
	s = ''
	for i in range(min1, max1 + 1, cd):
		s += str(i) + ' '
	print(s)


for r in range(int(input())):
	(num, x, y) = [int(i) for i in input().split()]
	AL = [2 ** 32] * num
	for a in range(1, 51):
		for d in range(1, 51):
			ls = a + (num - 1) * d
			AP = list(range(a, ls + 1, d))
			if x in AP and y in AP and (AL[num - 1] > a + (num - 1) * d):
				AL = AP
	print(*AL)


t = int(input())
for _ in range(t):
	(n, a, b) = map(int, input().split())
	d = b - a
	mn = d
	for i in range(1, n):
		if d % i == 0:
			mn = min(mn, d // i)
	count = 0
	ans = [a]
	while ans[-1] < b and count < n - 1:
		ans.append(ans[-1] + mn)
		count += 1
	temp = [a]
	while temp[-1] - mn > 0 and count <= n - 2:
		temp.append(temp[-1] - mn)
		count += 1
	ans = temp[1:] + ans
	while count <= n - 2:
		ans.append(ans[-1] + mn)
		count += 1
	print(*ans)


I = lambda : map(int, input().split())
for _ in [0] * int(input()):
	(n, x, y) = I()
	for i in range(n - 1, 0, -1):
		if (y - x) % i == 0:
			d = (y - x) // i
			break
	for i in range(n - 1, 0, -1):
		if y - i * d > 0:
			a1 = y - i * d
			break
	for j in range(n):
		print(a1 + j * d, end=' ')
	print(end='\n')


def listmake(k, x, y, n):
	li = []
	ans = x
	while ans <= y:
		li.append(ans)
		ans = ans + k
	ans = x
	while len(li) < n and ans - k > 0:
		li.append(ans - k)
		ans = ans - k
	ans = y
	while len(li) < n:
		li.append(ans + k)
		ans = ans + k
	for i in li:
		print(i, end=' ')
	print()
t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	for i in range(n - 1, 0, -1):
		if (y - x) // i == (y - x) / i:
			listmake((y - x) // i, x, y, n)
			break


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	diff = y - x
	temp = n - 2
	arr = []
	while temp >= 1:
		hold = diff / (temp + 1) - diff // (temp + 1)
		if hold == 0:
			my_diff = diff // (temp + 1)
			break
		temp -= 1
	arr.append(x)
	arr.append(y)
	if temp == 0:
		my_diff = y - x
		prev = x
		to_put = n - 2
		while prev - my_diff > 0 and to_put > 0:
			arr.append(prev - my_diff)
			to_put -= 1
			prev = prev - my_diff
		prev = y
		while to_put > 0:
			arr.append(prev + my_diff)
			prev = prev + my_diff
			to_put -= 1
	else:
		prev = x
		to_put = n - 2 - temp
		while prev + my_diff < y:
			arr.append(prev + my_diff)
			prev = prev + my_diff
		prev = x
		while to_put > 0 and prev - my_diff > 0:
			arr.append(prev - my_diff)
			prev = prev - my_diff
			to_put -= 1
		prev = y
		while to_put > 0:
			arr.append(prev + my_diff)
			prev = prev + my_diff
			to_put -= 1
	for i in range(n):
		print(arr[i], end=' ')
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	step = 1
	while diff % step or diff // step > n - 1:
		step += 1
	offset = n - (diff // step + 1)
	offset = min(offset, (x - 1) // step)
	answer = [x + step * (i - offset) for i in range(n)]
	print(*answer)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	q = y - x
	mn = float('inf')
	start = x
	ans = 0
	for d in range(1, q + 1):
		e = y - d * (n - 1)
		if e < 0:
			e %= d
		if e == 0:
			e += d
		if q % d == 0 and e <= x:
			w = e + (n - 1) * d
			if w < mn:
				ans = d
				mn = w
				start = e
	for i in range(n):
		print(start, end=' ')
		start += ans
	print()


from math import gcd
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	step_size = abs(x - y) / (n - 1)
	if step_size == int(step_size):
		step_size = int(step_size)
		if x > y:
			(x, y) = (y, x)
		i = x
		while i <= y:
			print(i, end=' ')
			i += step_size
		print()
	else:
		arr = []
		if x > y:
			(x, y) = (y, x)
		step_size = int(step_size) + 1
		val = abs(x - y)
		while val % step_size != 0:
			step_size += 1
		i = x
		while i <= y:
			arr.append(i)
			i += step_size
		i = x - step_size
		while len(arr) < n and i > 0:
			arr.append(i)
			i -= step_size
		i = y + step_size
		while len(arr) < n:
			arr.append(i)
			i += step_size
		print(*arr)


from sys import stdin, stdout

def INPUT():
	return list((int(i) for i in stdin.readline().split()))

def inp():
	return stdin.readline()

def out(x):
	return stdout.write(x)
import math
import random
J = 10 ** 19

def Fac(a):
	P = [1]
	i = 2
	while i <= a // 2 + 1:
		if a % i == 0:
			P.append(i)
		i += 1
	P.append(a)
	return P

def c(n, x, y):
	F = Fac(y - x)
	real = [10 ** 9 + 5]
	for d in F:
		for s in range(1, 51):
			A = []
			for i in range(s, s + n * d, d):
				A.append(i)
			if x in A and y in A:
				if max(A) <= max(real):
					real = A
	return real
for _ in range(int(input())):
	(n, x, y) = INPUT()
	print(*c(n, x, y))


from collections import deque
from math import ceil
t = int(input())
for _ in range(t):
	(n, x, y) = [int(p) for p in input().split()]
	ct = n
	d = 0
	while n > 0:
		diff = (y - x) / (ct - 1)
		if int(diff) == diff:
			d = int(diff)
			break
		else:
			ct -= 1
	final = deque()
	while x != y:
		final.append(x)
		x += d
	final.append(y)
	count = len(final)
	if count < n:
		while count < n:
			e = final[0] - d
			if e > 0:
				final.appendleft(e)
				count += 1
			else:
				break
		while count < n:
			final.append(final[-1] + d)
			count += 1
	print(*final)


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	a = y - x
	c = 0
	for c in range(1, a + 1):
		if a % c == 0 and n >= int(a / c) + 1:
			break
	if y - (n - 1) * c > 0:
		res = [str(y - i * c) for i in range(n)]
	else:
		temp = y % c
		if temp == 0:
			temp = c
		res = [str(temp + i * c) for i in range(n)]
	print(' '.join(res))


from math import *

def printDivisors(n):
	g = []
	i = 1
	while i * i < n:
		if n % i == 0:
			g.append(i)
		i += 1
	for i in range(int(sqrt(n)), 0, -1):
		if n % i == 0:
			g.append(n // i)
	return g
t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	no = y - x
	l = printDivisors(no)
	gd = 0
	for j in l:
		if n > j:
			gd = j
		else:
			break
	diff = no // gd
	for k in range(gd + 1):
		print(x + k * diff, end=' ')
	left = n - (gd + 1)
	w1 = 1
	w2 = 1
	for q in range(left):
		if x - w1 * diff > 0:
			print(x - w1 * diff, end=' ')
			w1 += 1
		else:
			print(y + w2 * diff, end=' ')
			w2 += 1


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if x > y:
		(x, y) = (y, x)
	p = y - x
	d = []
	i = 1
	while i * i <= p:
		if p % i == 0:
			d.append(i)
			d.append(p // i)
		i += 1
	d.sort()
	cd = -1
	f = -1
	for c in d:
		p = (y - x) // c
		if p + 1 <= n:
			if y - c * (n - 1) >= 1:
				cd = c
				f = y - c * (n - 1)
				break
			else:
				q = (x - 1) // c
				f = x - q * c
				cd = c
				break
	l = []
	for i in range(n):
		l.append(f + i * cd)
	print(*l)


import sys
import math
tests = int(input())
for i in range(tests):
	(n, x, y) = [int(i) for i in input().split()]
	res = [float('inf')]
	for start in range(1, 51):
		for d in range(1, 51):
			arr = [start + d * i for i in range(n)]
			if x in arr and y in arr and (arr[-1] < res[-1]):
				res = arr
	print(*res)


def func(n):
	arr = []
	p = int(n ** 0.5) + 1
	for i in range(1, p):
		if n % i == 0:
			if n // i == i:
				arr.append(i)
			else:
				arr.append(n // i)
				arr.append(i)
	return arr
for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	d = y - x
	f = 0
	arr = func(d)
	arr.sort()
	for i in range(1, d + 1):
		cur = i
		ans = []
		for j in range(x, y + i, i):
			ans.append(j)
		if len(ans) < n:
			for j in range(x - i, -1, -cur):
				if j > 0:
					ans.append(j)
				if len(ans) == n:
					break
		if len(ans) < n:
			t = y + cur
			while True:
				ans.append(t)
				t += cur
				if len(ans) == n:
					break
		if len(ans) == n and x in ans and (y in ans):
			print(*ans)
			f = 1
		if f == 1:
			break


from collections import deque
from math import ceil

def main():
	t = int(input())
	for i in range(t):
		(n, x, y) = map(int, input().split())
		result = find_best_array(x, y, array_size=n)
		print(*result)

def find_best_array(x, y, array_size):
	assert x < y
	min_delta = ceil((y - x) / (array_size - 1))
	while (y - x) % min_delta != 0:
		min_delta += 1
	delta = min_delta
	arr = deque([y])
	while len(arr) < array_size:
		arr.appendleft(arr[0] - delta)
	if arr[0] <= 0:
		how_many_should_add = abs(1 - arr[0])
		how_many_should_add = ceil(how_many_should_add / delta) * delta
		arr = [x + how_many_should_add for x in arr]
	return arr
main()


def solve(x, a, b):
	res = []
	delta = b - a
	for i in range(2, x):
		if (b - a) % i == 0:
			delta = (b - a) // i
	left = x
	i = 0
	while i < x and b > 0:
		res.append(b)
		i += 1
		left -= 1
		b -= delta
	res = res[::-1]
	for i in range(left):
		res.append(res[-1] + delta)
	for (i, b) in enumerate(res):
		if i == len(res) - 1:
			print(b)
		else:
			print(b, end=' ')
t = int(input())
for _ in range(t):
	inp = input().split()
	(x, a, b) = (int(inp[0]), min(int(inp[1]), int(inp[2])), max(int(inp[1]), int(inp[2])))
	solve(x, a, b)


from sys import stdin, stdout
t = int(stdin.readline().strip())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	flag = False
	for i in range(n - 1, 0, -1):
		if flag:
			flag = False
			break
		for j in range(i):
			if (x - y) % (i - j) != 0:
				continue
			if y > i * (y - x) // (i - j):
				print(*[y - i * ((-x + y) // (i - j)) + k * ((-x + y) // (i - j)) for k in range(n)])
				flag = True
				break


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	ans = []
	mini = 10 ** 18
	for i in range(1, 51):
		for d in range(1, 51):
			a = [i + j * d for j in range(n)]
			if x in a and y in a:
				if a[-1] < mini:
					mini = a[-1]
					ans = a
	print(*ans)


def yaar(n, A, B):
	d = B - A
	for x in reversed(range(1, n)):
		p = B - A
		if p / x == p // x:
			d = p // x
			break
	for x in reversed(range(1, n)):
		if B - d * x > 0:
			a = B - d * x
			break
	ans = []
	for x in range(n):
		ans.append(a + x * d)
	return ans
t = int(input())
for _ in range(t):
	(n, A, B) = map(int, input().split())
	ans = yaar(n, A, B)
	for x in ans:
		print(x, end=' ')
	print()


import sys
from collections import defaultdict as dd
from collections import deque
from functools import *
from fractions import Fraction as f
from copy import *
from bisect import *
from heapq import *
from math import *
from itertools import permutations, product

def eprint(*args):
	print(*args, file=sys.stderr)
zz = 1
if zz:
	input = sys.stdin.readline
else:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('all.txt', 'w')

def inc(d, c):
	d[c] = d[c] + 1 if c in d else 1

def bo(i):
	return ord(i) - ord('A')

def li():
	return [int(xx) for xx in input().split()]

def fli():
	return [float(x) for x in input().split()]

def comp(a, b):
	if a > b:
		return 2
	return 2 if a == b else 0

def gi():
	return [xx for xx in input().split()]

def fi():
	return int(input())

def pro(a):
	return reduce(lambda a, b: a * b, a)

def swap(a, i, j):
	(a[i], a[j]) = (a[j], a[i])

def si():
	return list(input().rstrip())

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

def gh():
	sys.stdout.flush()

def isvalid(i, j):
	return 0 <= i < n and 0 <= j < n

def bo(i):
	return ord(i) - ord('a')

def graph(n, m):
	for i in range(m):
		(x, y) = mi()
		a[x].append(y)
		a[y].append(x)
t = fi()
while t > 0:
	t -= 1
	(n, x, y) = mi()
	p = n - 2
	(x, y) = (max(x, y), min(x, y))
	for i in range(1, p + 2):
		if (x - y) % i == 0:
			ans = i
	p = (x - y) // ans
	for i in range(n):
		if x - i * p <= 0:
			break
		mini = x - i * p
	for i in range(n):
		print(mini + p * i, end=' ')
	print()


import sys

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 ** 19
MOD = 10 ** 9 + 7

def divisors(N: int) -> set:
	from math import sqrt
	s = {1, N}
	for i in range(2, int(sqrt(N)) + 1):
		if N % i == 0:
			s.add(i)
			s.add(N // i)
	return s

def check(d, x, y):
	arr = []
	i = y
	while len(arr) < N and i > 0:
		arr.append(i)
		i -= d
	i = y + d
	while len(arr) < N:
		arr.append(i)
		i += d
	if x not in arr:
		return [INF]
	arr.sort()
	return arr
for _ in range(INT()):
	(N, x, y) = MAP()
	dist = y - x
	divs = divisors(dist)
	mn = INF
	ans = []
	for div in divs:
		res = check(div, x, y)
		if res[-1] < mn:
			mn = res[-1]
			ans = res
	print(*ans)


for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	dif = y - x
	d = dif
	for i in range(n, 0, -1):
		if dif % i == 0:
			if dif // (dif // i) <= n - 1:
				d = dif // i
				break
	ans = []
	ans.append(x)
	start = x
	for i in range(dif // (dif // i)):
		ans.append(start + d)
		start += d
	start = x - d
	while start > 0 and len(ans) != n:
		ans.append(start)
		start -= d
	start = y
	while len(ans) != n:
		ans.append(start + d)
		start += d
	print(*ans)


import sys
input = sys.stdin.readline
from math import ceil
t = int(input())
while t != 0:
	t -= 1
	(n, x, y) = map(int, input().split())
	sz = ceil((y - x) / (n - 1))
	for i in range(sz, 50):
		if (y - x) % i == 0:
			sz = i
			break
	sy = y
	while n > 0 and sy > 0:
		print(sy, end=' ')
		sy -= sz
		n -= 1
	sy = y + sz
	while n > 0:
		print(sy, end=' ')
		sy += sz
		n -= 1
	print()


for _ in ' ' * int(input()):
	(n, x, y) = map(int, input().split())
	lst = [x, y]
	diff = y - x
	for i in range(n - 1, 0, -1):
		if diff % i == 0:
			num = i
			break
	for i in range(1, num):
		lst.append(x + i * (diff // num))
	n -= num + 1
	while x > diff // num and n > 0:
		x -= diff // num
		lst.append(x)
		n -= 1
	while n > 0:
		y += diff // num
		lst.append(y)
		n -= 1
	print(*lst)


def factors(x):
	original = x
	factors = set()
	for i in range(1, int(original ** 0.5) + 1):
		if x % i == 0:
			factors.add(i)
			factors.add(x // i)
	return sorted(factors)
for _ in range(int(input())):
	(n, x, y) = [int(x) for x in input().split()]
	minimum = y - x
	factorlist = factors(minimum)
	holder = 10 ** 7
	tobeprinted = []
	for i in factorlist:
		for j in range(1, x + 1):
			array = set()
			for k in range(1, n + 1):
				array.add(j + i * (k - 1))
			if x in array and y in array and (min(array) > 0):
				if holder > max(array):
					holder = max(array)
					tobeprinted = sorted(array)
	print(*tobeprinted)


def getdels(a):
	dels = []
	for i in range(1, a + 1):
		if a % i == 0:
			dels.append(i)
	return dels
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	kd = y - x
	minimal = [float('inf'), float('inf'), float('inf')]
	for k in getdels(kd):
		a1 = x % k
		imax = (x - a1) // k
		imin = (y - a1) // k - n
		if imin <= imax:
			if imin < 0:
				imin = 0
			for i in range(imin, imax + 1):
				ai = a1 + i * k
				ain = a1 + (i + n - 1) * k
				if 0 < ai <= x and ain >= y and ((ain - ai) // k < n):
					if minimal[1] >= ain:
						minimal[1] = ain
						minimal[0] = ai
						minimal[2] = k
	print(*[i for i in range(minimal[0], minimal[1] + 1, minimal[2])])


def sp():
	return map(int, input().split())
t = int(input())
for _ in range(t):
	(n, x, y) = sp()
	if n == 2:
		print(x, y)
		continue
	dif = y - x
	k = n - 1
	while (y - x) % k:
		k -= 1
	gap = dif // k
	if y // gap < n:
		extra = n - y // gap - 1
		i = 0
		if y + extra * gap - (n - 1) * gap <= 0:
			extra += 1
		while i < n:
			print(y + extra * gap - i * gap, end=' ')
			i += 1
	else:
		i = 0
		while i < n:
			print(y - i * gap, end=' ')
			i += 1
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().strip().split())
	flag = False
	for i in range(1, 51):
		for j in range(1, 51):
			k = j
			arr = []
			for l in range(n):
				arr.append(k)
				k += i
			if x in arr and y in arr:
				print(*arr)
				flag = True
				break
		if flag:
			break


t = int(input())
for ii in range(t):
	(n, x, y) = map(int, input().split())
	if y <= n:
		ans = [-1] * n
		for i in range(n):
			ans[i] = i + 1
		print(*ans)
		continue
	if n == 2:
		print(x, y)
		continue
	num = (y - x) // (n - 1)
	if num * (n - 1) == y - x:
		ans = [-1] * n
		ans[0] = x
		ans[-1] = y
		for i in range(1, n - 1):
			ans[i] = ans[i - 1] + num
		print(*ans)
		continue
	maxdiff = y - x
	perfect = False
	for i in range(n - 3, 0, -1):
		num = maxdiff // (i + 1)
		if num * (i + 1) == maxdiff:
			perfect = True
			rem = n - (i + 2)
			lowest = x - num * rem
			up = 0
			while lowest <= 0:
				rem -= 1
				up += 1
				lowest = x - num * rem
				if rem == 0:
					break
			ans = [lowest]
			for i in range(1, n):
				ans.append(ans[-1] + num)
			print(*ans)
			break
	if not perfect:
		diff = maxdiff
		rem = n - 2
		lowest = x - rem * diff
		while lowest <= 0:
			rem -= 1
			lowest = x - diff * rem
			if rem == 0:
				break
		ans = [lowest]
		for i in range(1, n):
			ans.append(ans[-1] + diff)
		print(*ans)


try:

	def all_factors(n):
		f = []
		for q in range(1, n + 1):
			if n % q == 0:
				f.append(q)
		return f
	t = int(input())
	for i in range(t):
		(n, x, y) = [int(x) for x in input().split()]
		z = y - x
		for j in all_factors(z):
			if y <= j * (n - 1) + x:
				b = j
				break
		r = ''
		a = x
		m = 0
		while a <= y and m != n:
			r += f'{a} '
			m += 1
			a += b
		a = x - b
		while a > 0 and m != n:
			r += f'{a} '
			m += 1
			a -= b
		a = y + b
		while m != n:
			r += f'{a} '
			m += 1
			a += b
		print(r)
except:
	pass


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	raznost = y - x
	shag1 = raznost
	min1 = 11111111111100000
	for shag in range(1, raznost + 1):
		if raznost % shag != 0 or raznost // shag + 1 > n:
			pass
		else:
			max1 = y
			p = n - 1
			if y % shag == 0:
				p += 1
			p -= y // shag
			if p > 0:
				max1 += shag * p
			if max1 < min1:
				min1 = max1
				shag1 = shag
	for i in range(n):
		print(min1, end=' ')
		min1 -= shag1
	print()


from sys import stdin, stdout
input = stdin.buffer.readline
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	x = y - x
	i = 1
	c = 10000
	while i * i <= x:
		if not x % i and x // i < n:
			c = min(c, i)
		if not x % i and i < n:
			c = min(c, x // i)
		i += 1
	x = y % c
	if not x:
		x += c
	ans = []
	i = 0
	for i in range(51):
		ans.append(i * c + x)
	for i in range(51):
		if i + n - 1 < 51 and ans[i + n - 1] >= y:
			print(*ans[i:i + n])
			break


testCases = int(input())
while testCases != 0:
	testCases -= 1
	(n, x, y) = [int(a) for a in input().split()]
	differenceBtnXAndY = y - x
	numberOfHiddenElements = n - 2
	i = numberOfHiddenElements + 1
	while differenceBtnXAndY % i != 0:
		i -= 1
	if differenceBtnXAndY % i != 0:
		interval = differenceBtnXAndY
	else:
		interval = int(differenceBtnXAndY / i)
	resultingArray = []
	for j in range(x, y + interval, interval):
		resultingArray.append(j)
	numberOfHiddenElements = n - len(resultingArray)
	minElement = x
	for j in range(0, numberOfHiddenElements):
		minElement -= interval
		if minElement > 0:
			resultingArray.append(minElement)
	numberOfHiddenElements = n - len(resultingArray)
	maxElement = y
	for j in range(0, numberOfHiddenElements):
		maxElement += interval
		resultingArray.append(maxElement)
	for element in resultingArray:
		print(element, end=' ')
	print()


import math
import sys

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

def ML():
	return list(MI())

def I():
	return int(input())

def LOOP(SizE, solve):
	for XIX in range(SizE):
		solve()

def solve():
	(n, x, y) = MI()
	res = list()
	d = max(x, y)
	x = min(x, y)
	y = d
	d = abs(x - y)
	pre = [math.inf, y]
	for xx in range(1, d + 1):
		if d % xx == 0:
			t1 = n - 1
			temp = y
			while t1 > 0:
				if temp - xx > 0:
					temp -= xx
				else:
					break
				t1 -= 1
			if temp <= x:
				pp = temp
				temp = y
				while t1 > 0:
					temp += xx
					t1 -= 1
				if temp <= pre[0]:
					pre[0] = temp
					pre[1] = xx
	while n > 0:
		res.append(pre[0])
		pre[0] -= pre[1]
		n -= 1
	print(*res)
try:
	LOOP(I(), solve)
except:
	print(sys.exc_info())


import math

def sol1(a, b, x, y, n):
	t = min(a - x, n)
	a -= t
	n -= t
	t = min(b - y, n)
	b -= t
	n -= t
	return a * b

def sol2(a, b, x, y, n):
	t = min(b - y, n)
	b -= t
	n -= t
	t = min(a - x, n)
	a -= t
	n -= t
	return a * b
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	d = 1
	for i in range(n - 1, 0, -1):
		if diff % i == 0:
			d = diff // i
			for j in range(x, y + 1, d):
				print(j, end=' ')
			n -= i + 1
			break
	while n:
		if x - d > 0:
			x -= d
			print(x, end=' ')
			n -= 1
		else:
			break
	while n:
		y += d
		print(y, end=' ')
		n -= 1
	print()


import sys, os
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
input = lambda : sys.stdin.readline().strip()
li = lambda : list(map(int, input().split()))
I = lambda : int(input())

def factors(n):
	l = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			l.append(i)
			l.append(n // i)
	return sorted(l)
for _ in range(I()):
	(n, x, y) = li()
	if n == 2:
		print(x, y)
	else:
		ans = 10000000000.0
		ansl = []
		l = factors(y - x)
		for i in l:
			c = 2
			cur = x
			m = y
			temp = [x, y]
			while cur < y and c < n:
				cur += i
				if cur == y:
					break
				c += 1
				m = max(cur, m)
				temp.append(cur)
			if cur != y and cur + i != y:
				continue
			cur = x
			while cur > 0 and c < n:
				cur -= i
				if cur <= 0:
					break
				temp.append(cur)
				c += 1
				m = max(cur, m)
			cur = y
			while c < n:
				cur += i
				temp.append(cur)
				c += 1
				m = max(cur, m)
			if m < ans:
				ansl = temp
				ans = m
		print(*ansl)


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split(' '))
	d = abs(x - y)
	diff = d
	for i in range(1, d + 1):
		if d % i == 0 and d / i < n:
			diff = i
			break
	a = min(x, y)
	c = 0
	while a - diff > 0 and c <= n - 2 - d // diff:
		c = c + 1
		a = a - diff
	for i in range(1, n + 1):
		print(a + (i - 1) * diff, end=' ')
	print()


def check(n, x, y, diff):
	candidate = y - diff
	output = [y]
	while candidate > 0 and len(output) < n:
		output.append(candidate)
		candidate -= diff
	candidate = y + diff
	while len(output) < n:
		output.append(candidate)
		candidate += diff
	output.sort()
	return output
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	output = [x, y]
	if n > 2:
		diff = y - x
		output = check(n, x, y, diff)
		diff -= 1
		while diff >= (y - x + (n - 1) - 1) // (n - 1):
			if (y - x) % diff == 0:
				tmp = check(n, x, y, diff)
				if tmp[n - 1] < output[n - 1]:
					output = tmp
			diff -= 1
	print(' '.join([str(x) for x in output]))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	elif y - x == 1:
		lis = [y, x]
		n -= 2
		for i in range(n):
			x -= 1
			if x > 0:
				lis.append(x)
			else:
				lis.append(y + 1)
				y += 1
		print(*lis)
	else:
		lis = [x, y]
		f1 = 0
		zmax = n - 2
		n -= 2
		d = 1
		ke = -1
		diff = y - x
		while d < y - x:
			if diff % d == 0:
				zu = diff // d - 1
				if zu <= zmax:
					ke = zu
					f1 = 1
					break
			d += 1
		if f1 == 1:
			co = 1
			for i in range(ke):
				lis.append(x + (co + i) * d)
				n -= 1
			v1 = x - d
			while v1 > 0 and n > 0:
				lis.append(v1)
				v1 -= d
				n -= 1
			y += d
			while n > 0:
				lis.append(y)
				n -= 1
				y += d
			print(*lis)
		else:
			x -= diff
			while x > 0 and n > 0:
				lis.append(x)
				n -= 1
				x -= diff
			y += diff
			while n > 0:
				lis.append(y)
				n -= 1
				y += diff
			print(*lis)


for t in range(int(input())):
	(n, x, y) = [int(i) for i in input().split()]
	minval = int(1000000000.0)
	res = int(10000000000.0)
	res1 = int(1000000000.0)
	res2 = int(1000000000.0)
	for a1 in range(1, x + 1):
		for d in range(1, y - x + 1):
			if (x - a1) % d == 0 and (y - a1) % d == 0 and ((x - a1) // d < n) and ((y - a1) // d < n):
				res = a1 + d * (n - 1)
				if res < minval:
					minval = res
					res1 = a1
					res2 = d
	print(' '.join((str(res1 + res2 * (i - 1)) for i in range(1, n + 1))))


import sys
import math
inputlines = sys.stdin.readlines()
number_of_testcases = int(inputlines[0])
for i in range(number_of_testcases):
	(n, x, y) = list(map(int, inputlines[i + 1].split(' ')))
	difference = y - x
	if difference % (n - 1) == 0:
		final_list = list(range(x, y + 1, difference // (n - 1)))
	else:
		for i in range(1, difference + 1):
			if difference % i == 0:
				if difference // i < n:
					need_to_go_back = n - 1 - difference // i
					can_go_back = (x - 1) // i
					will_go_back = min(need_to_go_back, can_go_back)
					start = x - will_go_back * i
					final_list = list(range(start, start + n * i, i))
					break
	for i in final_list:
		print(i, end=' ')
	print('')


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
		continue
	ans = []
	m = 10 ** 10
	for i in range(1, 51):
		if (y - x) % i == 0:
			t = i
			if y <= x + (n - 1) * t:
				anss = []
				tt = max(1 if x % t == 0 else 0, (y - (n - 1) * t) // t)
				for j in range(tt, tt + n):
					anss.append(j * t + x % t)
				if max(anss) < m:
					ans = anss
					m = max(anss)
	print(*ans)


for _ in range(int(input())):
	(a, x, y) = map(int, input().split())
	for i in range(1, 51):
		for j in range(1, 51):
			k = j
			(c, d) = (0, 0)
			l = []
			for _ in range(a):
				if k == x:
					c = 1
				if k == y:
					d = 1
				l.append(k)
				k += i
			if c + d == 2:
				print(*l)
				break
		if c + d == 2:
			break


for _ in [0] * int(input()):
	(a, b, c) = [int(x) for x in input().split()]
	i = a
	while (c - b) % (i - 1) != 0:
		i -= 1
	difference = (c - b) // (i - 1)
	left_term = (b - 1) // difference
	ans = max(0, a - (left_term + i)) * difference + c
	print(*[ans - i * difference for i in range(a)])


import sys
input = sys.stdin.readline
T = int(input())
for _ in range(T):
	(n, x, y) = map(int, input().split())
	v = y - x
	diff = v
	npts = 0
	A = []
	for i in range(n - 1, 0, -1):
		if v % i == 0:
			diff = v // i
			npts = i
			break
	for i in range(x, y + 1, diff):
		A.append(i)
	for i in range(x - diff, 0, -diff):
		if len(A) >= n:
			break
		A.append(i)
	for i in range(y + diff, 10 ** 9 + 1, diff):
		if len(A) >= n:
			break
		A.append(i)
	print(*A)


def main():
	for _ in range(int(input())):
		(n, x, y) = map(int, input().split())
		possibleterms = n - 1
		givendifference = y - x
		while possibleterms != 1:
			if givendifference % possibleterms == 0:
				break
			possibleterms -= 1
		termdiff = givendifference // possibleterms
		startterm = x
		termsgot = possibleterms + 1
		while startterm - termdiff > 0:
			if termsgot == n:
				break
			startterm -= termdiff
			termsgot += 1
		endterm = y
		while termsgot != n:
			endterm += termdiff
			termsgot += 1
		for term in range(startterm, endterm + 1, termdiff):
			print(term, end=' ')
		print()
main()


def solve():
	(n, x, y) = map(int, input().split())
	a = [0 for i in range(n)]
	ans = [10000000, 0, 0]
	for i in range(1, 50):
		if (y - x) % i == 0 and (y - x) // i < n:
			yy = y // i
			xx = x // i
			pos = min(xx, n - (yy - xx) - 1)
			res = x + (n - pos - 1) * i
			if x - pos * i == 0:
				res += i
			if res < ans[0]:
				ans[0] = res
				ans[1] = x - pos * i
				if ans[1] == 0:
					ans[1] += i
				ans[2] = i
	a[0] = ans[1]
	for i in range(1, n):
		a[i] = a[i - 1] + ans[2]
	print(*a)
for i in range(int(input())):
	solve()


from math import inf
t = int(input())
while t:
	(n, x, y) = map(int, input().split())
	ans = [inf]
	for a in range(1, 51):
		for d in range(1, 51):
			ap = [term for term in range(a, a + (n - 1) * d + 1, d)]
			if x in ap and y in ap:
				ans = ap if ap[-1] < ans[-1] else ans
	for i in ans:
		print(i, end=' ')
	print()
	t -= 1


import sys
input = sys.stdin.readline
INF = float('inf')

def get_measure(n):
	l = list()
	for i in range(1, n + 1):
		if n % i == 0:
			l.append(i)
	return l
tc = int(input())
for _ in range(tc):
	(n, x, y) = map(int, input().split())
	sub = y - x
	measure = get_measure(sub)
	ans = [x, y]
	for i in measure:
		if sub // i - 1 <= n - 2:
			dis = i
			break
	tmpx = x + dis
	while tmpx < y:
		ans.append(tmpx)
		tmpx += dis
		n -= 1
	tmpx = x - dis
	while tmpx > 0 and n > 2:
		ans.append(tmpx)
		tmpx -= dis
		n -= 1
	tmpy = y + dis
	while n > 2:
		ans.append(tmpy)
		tmpy += dis
		n -= 1
	for i in ans:
		print(i, end=' ')
	print()


for i in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	m = x + (y - x) * (n - 1)
	q = y - x
	for d in range(1, int((y - x) ** 0.5) + 1):
		if (y - x) % d == 0:
			if (y - x) // d + 1 <= n:
				if y // d + min(1, y % d) >= n:
					(m, q) = (y, d)
					break
				elif (n - y // d - min(1, y % d)) * d + y < m:
					(m, q) = ((n - y // d - min(1, y % d)) * d + y, d)
			d = (y - x) // d
			if (y - x) // d + 1 <= n:
				if y // d + min(1, y % d) >= n:
					(m, q) = (y, d)
					break
				elif (n - y // d - min(1, y % d)) * d + y < m:
					(m, q) = ((n - y // d - min(1, y % d)) * d + y, d)
	print(*list(range(m - q * (n - 1), m + 1, q)))


for _ in range(int(input())):
	(a, b, x) = [int(i) for i in input().split()]
	r = 0
	for i in range(a - 1, -1, -1):
		if (x - b) % i == 0:
			r = (x - b) // i
			break
	v = [x]
	while a > 1:
		v.append(x - r)
		x -= r
		a -= 1
	t = max(v)
	for i in v:
		if i <= 0:
			print(t + r, end=' ')
			t += r
		else:
			print(i, end=' ')
	print()


def factors(b):
	result = []
	i = 1
	while i * i <= b:
		if b % i == 0:
			result.append(i)
			if b // i != i:
				result.append(b // i)
		i += 1
	return result

def make(n, x, y, li):
	bruh = x
	ans = []
	c = 0
	while bruh != y:
		ans.append(bruh)
		bruh = bruh + li
		c = c + 1
	ans.append(y)
	c = c + 1
	n = n - c
	bruh = x - li
	while bruh > 0 and n != 0:
		ans.append(bruh)
		bruh = bruh - li
		n = n - 1
	bruh = y + li
	while n != 0:
		ans.append(bruh)
		bruh = bruh + li
		n = n - 1
	return ans
x = int(input())
for z in range(x):
	(n, x, y) = map(int, input().split())
	l = factors(y - x)
	l.sort()
	for i in range(len(l)):
		if n >= (y - x) // l[i] + 1:
			z = make(n, x, y, l[i])
			print(*z)
			break


import math
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		d = y - x
		diff = n - 1
		while d % diff != 0 and diff > 1:
			diff -= 1
		if diff == 1:
			diff = d
		else:
			diff = d // diff
		if y - (n - 1) * diff <= 0:
			y += diff * math.ceil(abs((y - (n - 1) * diff - 1) / diff))
		for i in range(n):
			print(y - i * diff, end=' ')
		print()


i = input
r = range
for _ in r(int(i())):
	(n, x, y) = map(int, i().split())
	z = y - x
	for d in r(n - 1, 0, -1):
		if z % d < 1:
			break
	e = z // d
	s = max(y - (n - 1) * e, (y - 1) % e + 1)
	print(*r(s, s + e * n, e))


from bisect import bisect_left
import os
import sys
from io import BytesIO, IOBase
from collections import Counter, defaultdict
from collections import deque
from functools import cmp_to_key
import math
import heapq

def sin():
	return input()

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

def sain():
	return input().split()

def iin():
	return int(sin())
MAX = float('inf')
MIN = float('-inf')
MOD = 1000000007

def sieve(n):
	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
	s = set()
	for p in range(2, n + 1):
		if prime[p]:
			s.add(p)
	return s

def readTree(n, m):
	adj = [deque([]) for _ in range(n + 1)]
	for _ in range(m):
		(u, v) = ain()
		adj[u].append(v)
		adj[v].append(u)
	return adj

def main():
	for _ in range(iin()):
		(n, x, y) = ain()
		j = y - x
		p = n - 1
		ans = -1
		for i in range(p, 0, -1):
			if j % i == 0:
				ans = i
				break
		if ans == -1:
			print(x, y)
		else:
			d = deque([x])
			t = j // ans
			for i in range(ans):
				d.append(d[-1] + t)
			rem = n - ans - 1
			p = d[0]
			while p - t > 0 and rem > 0:
				d.appendleft(p - t)
				p -= t
				rem -= 1
			while rem > 0:
				d.append(d[-1] + t)
				rem -= 1
			print(*d)
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')
if os.getcwd() == 'D:\\code':
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
	input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


t = int(input())
for _ in range(t):
	(n, x, y) = [int(i) for i in input().split()]
	d = 1
	while d <= y - x:
		current = y
		ans = []
		num_of_elements = 0
		while current >= 1 and num_of_elements < n:
			ans.append(current)
			current -= d
			num_of_elements += 1
		if x not in ans:
			d += 1
			continue
		ans = ans[-1::-1]
		current = y + d
		if num_of_elements < n:
			while num_of_elements < n:
				ans.append(current)
				current += d
				num_of_elements += 1
		for i in ans:
			print(i, end=' ')
		print()
		break


t = int(input())
while t > 0:
	(n, x, y) = list(map(int, input().split()))
	if (y - x) % (n - 1) == 0:
		d = (y - x) // (n - 1)
		for i in range(n):
			if i != n - 1:
				print(x, end=' ')
			else:
				print(x)
			x += d
	else:
		i = n - 2
		while (y - x) % i != 0:
			i -= 1
		d = (y - x) // i
		temp = y
		for j in range(n):
			if j != n - 1:
				print(y, end=' ')
			else:
				print(y)
			y -= d
			if y > 0:
				continue
			else:
				y = temp + d * (n - j - 1)
	t -= 1


t = int(input())
for _ in range(t):
	temp = list(map(int, input().split(' ')))
	n = temp[0]
	x = temp[1]
	y = temp[2]
	inrange = abs(x - y)
	res = [x, y]
	if n == 2:
		print(x, y)
	else:
		for u in range(n - 1, 2 - 1, -1):
			if abs(x - y) % u == 0:
				t1 = min(x, y)
				t2 = abs(x - y) // u
				inrange = t2
				for v in range(u - 1):
					res.append(t1 + t2)
					t1 += t2
				break
		cur1 = x
		cur2 = y
		while len(res) < n:
			if cur1 - inrange > 0:
				res.append(cur1 - inrange)
				cur1 = cur1 - inrange
			else:
				res.append(cur2 + inrange)
				cur2 += inrange
		for x in res:
			print(x, end=' ')
		print('')


n = int(input())
for _ in range(n):
	(n, x, y) = map(int, input().split())
	dif = y - x
	flag = 0
	for j in range(n, 1, -1):
		for m in range(1, j):
			d = dif // (j - m)
			a1 = x - (m - 1) * d
			if (dif % (j - m) == 0) & (a1 > 0):
				flag = 1
				break
		if flag:
			break
	d = dif // (j - m)
	a1 = x - (m - 1) * d
	print(*[a1 + d * i for i in range(n)])


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	t = 0
	if x > y:
		(x, y) = (y, x)
	for i in range(1, x + 1):
		kk = i
		kkk = (y - i) // (n - 1)
		if (y - i) % (n - 1) == 0 and (x - i) % kkk == 0:
			t = 1
			break
	if t == 0:
		rr = 0
		for i in range(y, 5000):
			for j in range(1, x + 1):
				kk = j
				kkk = (i - j) // (n - 1)
				if (i - j) % (n - 1) == 0 and (x - j) % kkk == 0 and ((y - j) % kkk == 0):
					rr = 1
					break
			if rr == 1:
				break
		for j in range(n):
			print(kk, end=' ')
			kk += kkk
	else:
		for i in range(n):
			print(kk, end=' ')
			kk += kkk
	print()


for ad in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	l = [0] * n
	l[-1] = y
	dif = y - x
	for i in range(n - 1):
		if dif % (n - 1 - i) == 0:
			l[i] = x
			c = dif // (n - 1 - i)
			break
	t = 0
	for i in range(n - 2, -1, -1):
		if l[i + 1] - c > 0 and t == 0:
			l[i] = l[i + 1] - c
		else:
			t = 1
			l[i] = max(l) + c
	for i in l:
		print(i, end=' ')
	print()


for i in range(int(input())):
	(n, a, b) = [int(a) for a in input().split()]
	d = b - a
	for i in range(1, 50):
		flag = 0
		if d % i == 0:
			r = d // i
			if r > n - 1:
				continue
			else:
				arr = []
				count = 0
				for j in range(a, b + 1, i):
					arr.append(j)
					count = count + 1
				j = a - i
				while j >= 1 and count < n:
					arr.append(j)
					j = j - i
					count = count + 1
				j = b + i
				while count < n:
					arr.append(j)
					j = j + i
					count = count + 1
				break
		else:
			continue
	print(*arr)


t = int(input())
for i in range(t):
	(n, a, b) = [int(i) for i in input().split()]
	l = []
	if n == 2:
		l += [a]
		l += [b]
	else:
		diff = n - 1
		temp = b - a
		while diff > 1 and temp % diff != 0:
			diff -= 1
		d = temp / diff
		e = b
		while n > 0 and e > 0:
			l += [e]
			e -= d
			n -= 1
		e = b + d
		while n > 0:
			l += [e]
			e += d
			n -= 1
	for e in l:
		print(int(e), end=' ')
	print()


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	dif = y - x
	best = 2 ** 20
	best_list = None
	for d in range(1, dif + 1):
		if d * (n - 1) < dif:
			continue
		if dif % d != 0:
			continue
		steps = dif // d - 1
		l = [x] + [x + d * (s + 1) for s in range(steps)] + [y]
		rest = n - steps - 2
		while l[0] - d > 0 and rest:
			rest -= 1
			l = [l[0] - d] + l
		while rest:
			rest -= 1
			l += [l[-1] + d]
		if max(l) < best:
			best = max(l)
			best_list = l
	print(*best_list)


import math

def isInt(a):
	return math.floor(a) == a

def fn(n, x, y):
	mind = float('inf')
	mins = float('inf')
	mina = float('inf')
	for d in range(1, y - x + 1):
		for a in range(1, x + 1):
			if isInt((x - a) / d) and isInt((y - a) / d) and ((x - a) / d <= n - 1) and ((y - a) / d <= n - 1):
				if a + (n - 1) * d < mins:
					mins = a + (n - 1) * d
					mind = d
					mina = a
	return (mina, mind)

def solve(n, x, y):
	(a, d) = fn(n, x, y)
	for i in range(n):
		print(a + i * d, end=' ')
	print('', end='\n')
for _ in range(int(input())):
	[n, x, y] = [int(i) for i in input().rstrip().split(' ')]
	solve(n, x, y)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	s = []
	for i in range(1, n + 1):
		if int((y - x) % i) == 0:
			s.append((y - x) // i)
	maxi = 10 ** 9 + 7
	bstart = -1
	bdiff = -1
	besta = []
	for d in s:
		for start in range(1, 51):
			hasx = False
			hasy = False
			a = []
			for i in range(n):
				a.append(start)
				if x == start:
					hasx = True
				if y == start:
					hasy = True
				start += d
			if maxi > start + (n - 1) * d and (hasx and hasy):
				maxi = start + (n - 1) * d
				bstart = start
				besta = a[:]
				bdiff = d
	print(*besta)


def main():
	for _ in range(int(input())):
		(n, x, y) = map(int, input().split())
		l = []
		for i in range(n - 1, 0, -1):
			if (y - x) % i == 0:
				for k in range(n - i):
					if x - (n - i - 1 - k) * ((y - x) // i) > 0:
						l = [x - (n - i - 1 - k) * ((y - x) // i)]
						for j in range(n - 1):
							l.append(l[-1] + (y - x) // i)
						break
				if l:
					break
		if l:
			print(*l)
main()


import os
import sys
from io import BytesIO, IOBase
import math

def main():
	pass
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 binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(i)
			n = n / i
	if n > 2:
		l.append(int(n))
	return l

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

def maxPrimeFactors(n):
	maxPrime = -1
	while n % 2 == 0:
		maxPrime = 2
		n >>= 1
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			maxPrime = i
			n = n / i
	if n > 2:
		maxPrime = n
	return int(maxPrime)
for xyz in range(0, int(input())):
	(n, x, y) = map(int, input().split())
	t = y - x
	s = 100000000
	ans = []
	for p1 in range(0, n - 1):
		for p2 in range(p1 + 1, n):
			if t % (p2 - p1) == 0:
				d = t // (p2 - p1)
				a = x - d * p1
				if a > 0:
					an = (n - 1) * d + a
					if an < s:
						s = an
						ans = [a, d]
	for i in range(0, n):
		print(ans[0] + i * ans[1], end=' ')
	print()


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		r1 = y - x
		j = 1
		m = []
		while j * j <= r1:
			if r1 % j == 0:
				m.append(j)
				m.append(r1 // j)
			j += 1
		m = sorted(m)
		k1 = 0
		n -= 2
		for l in range(len(m)):
			if m[l] <= n + 1:
				k1 = m[l]
		o = []
		o.append(x)
		o.append(y)
		if k1 == 0:
			r = r1
		else:
			r = r1 // k1
		i1 = 1
		while x + i1 * r <= y - r:
			o.append(x + i1 * r)
			i1 += 1
			n -= 1
		i1 = 1
		while n > 0 and x - i1 * r > 0:
			o.append(x - i1 * r)
			i1 += 1
			n -= 1
		i1 = 1
		while n > 0:
			o.append(y + r * i1)
			n -= 1
			i1 += 1
		o = sorted(o)
		for x in o:
			print(x, end=' ')
		print(' ')


import sys
from collections import Counter, defaultdict
from math import fsum, inf, sqrt, gcd, ceil
from itertools import combinations, permutations
flush = lambda : sys.stdout.flush
ip = lambda : input
ii = lambda : int(input())
r = lambda : map(int, input().split())
rr = lambda : list(r())

def solve():
	(n, x, y) = r()
	arr = []
	if n == 2:
		print(x, y)
		return
	d = y - x
	ans = []
	curr = float('inf')
	for i in range(1, 55):
		arr = [y]
		if d % i != 0:
			continue
		k = 1
		while len(arr) < n:
			if y - i * k < 1:
				break
			arr.append(y - i * k)
			k += 1
		k = 1
		while len(arr) < n:
			arr.append(y + i * k)
			k += 1
		if x in arr and y in arr and (len(arr) == n):
			if (m := (max(arr) < curr)):
				curr = m
				ans = arr
	print(*ans)
for _ in range(ii()):
	solve()


m = int(input())
for i in range(m):
	a = list(map(int, input().split()))
	n = a[0]
	x = a[1]
	y = a[2]
	a = y - x
	g = a
	for i in range(1, a + 1):
		if a % i == 0 and x + i * (n - 1) >= y:
			g = i
			break
	for i in range(n - 1):
		y -= g
		if y <= 0:
			y += g
			break
	for i in range(n):
		print(y, end=' ')
		y += g
	print()


for _ in range(int(input())):
	(n, x, y) = [x for x in map(int, input().split())]
	remaining = n - 1
	lis = [min(x, y)]
	diff = abs(x - y)
	temp = remaining
	while temp > 0:
		if diff % temp == 0:
			remaining -= temp
			break
		else:
			temp -= 1
	for i in range(temp):
		lis.append(lis[-1] + diff // temp)
	lis.append(lis.pop(0))
	while remaining > 0 and lis[-1] - diff // temp > 0:
		lis.append(lis[-1] - diff // temp)
		remaining -= 1
	ma = max(lis)
	if remaining > 0:
		lis.append(ma + diff // temp)
		remaining -= 1
	while remaining > 0:
		lis.append(lis[-1] + diff // temp)
		remaining -= 1
	lis = [str(x) for x in lis]
	lis = ' '.join(lis)
	print(lis)


t = int(input())
for you in range(t):
	l = input().split()
	n = int(l[0])
	x = int(l[1])
	y = int(l[2])
	diff = y - x
	maxa = 10 ** 18
	ans = 0
	s = 0
	for i in range(1, diff + 1):
		if diff % i:
			continue
		start = x % i
		if start == 0:
			start += i
		end = start + (n - 1) * i
		if end < y:
			start += y - end
			end = y
			if start > x:
				continue
		if end < maxa:
			maxa = end
			ans = i
			s = start
	for i in range(n):
		print(s + i * ans, end=' ')
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = []
	for d in range(1, y - x + 1):
		if (y - x) % d != 0:
			continue
		curr = y
		count = 0
		arr = []
		found = False
		while curr >= 1 and count < n:
			if curr == x:
				found = True
			arr.append(curr)
			curr -= d
			count += 1
		curr = y
		for i in range(count, n):
			curr += d
			if curr == x:
				found = True
			arr.append(curr)
		arr.sort()
		if found:
			if len(ans) == 0 or ans[-1] > arr[-1]:
				ans = arr
	print(*ans)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = None
	remain = 0
	for i in range(n, 1, -1):
		if (y - x) % (i - 1) == 0:
			remain = n - i
			d = (y - x) // (i - 1)
			break
	start = x
	end = y
	arr = []
	while start <= end:
		arr.append(start)
		start += d
	if remain > 0:
		start = x - d
		while remain > 0 and start > 0:
			arr.append(start)
			remain -= 1
			start -= d
		end = y + d
		while remain > 0:
			arr.append(end)
			end += d
			remain -= 1
	print(*arr)


def f(a, n):
	i = 1
	while i * i < a:
		if a % i == 0:
			if i * (n - 1) >= a:
				return i
		i += 1
	for i in range(int(sqrt(a)), 0, -1):
		if a % i == 0:
			b = a // i
			if b * (n - 1) >= a:
				return b
from math import sqrt
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		i = f(y - x, n)
		ans = []
		element = y
		z = n
		while z > 0 and element > 0:
			ans.append(element)
			element -= i
			z -= 1
		if len(ans) < n:
			x = len(ans)
			while x < n:
				x += 1
				ans.append(max(ans) + i)
		print(*ans)


t = int(input())
while t > 0:
	(n, x, y) = list(map(int, input().split()))
	min_val = 100000.0
	min_diff = 0
	for xpos in range(0, n - 1):
		for ypos in range(xpos + 1, n):
			l = ypos - xpos
			if (y - x) % l > 0:
				continue
			diff = (y - x) / l
			max_item = x + (n - 1 - xpos) * diff
			if max_item < min_val and x - xpos * diff >= 1:
				min_val = int(max_item)
				min_diff = int(diff)
	first_num = min_val - (n - 1) * min_diff
	for index in range(0, n):
		print('{}'.format(first_num + index * min_diff), end=' ')
	print('')
	t -= 1


import math
t = int(input(''))
for i in range(t):
	(n, x, y) = map(int, input('').split())
	best = 0
	dif = y - x
	m = x
	k = n
	for j in range(1, y - x + 1):
		if (dif + j) % j == 0 and (dif + j) / j <= n:
			best += j
			break
	if best == 0:
		best += 1
	k -= (dif + best) / best
	while m >= 1 and k > 0:
		m -= best
		k -= 1
	if m <= 0:
		m += best
	for p in range(n):
		print(m, end=' ')
		m += best
	print('\n')


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	mn = 1000000000
	ans = []
	for i in range(1, y - x + 1):
		if (y - x) % i == 0:
			for j in range(1, x + 1):
				arr = [j + i * k for k in range(n)]
				if x in arr and y in arr:
					if mn > arr[-1]:
						mn = arr[-1]
						ans = arr
	print(*ans)


def powerset(s):
	x = len(s)
	m = [1 << i for i in range(x)]
	for i in range(1 << x):
		yield [ss for (m, ss) in zip(m, s) if i & m]

def divisions(divs):
	res = list(powerset(divs))
	for i in range(len(res)):
		a = 1
		for j in range(len(res[i])):
			a *= res[i][j]
		res[i] = a
	res.sort()
	return res

def findMinRD(divs, n):
	di = divisions(divs)
	diff = 1
	for i in range(len(divs)):
		diff *= divs[i]
	i = 0
	while len(di) > 1:
		if di[1] >= n:
			break
		di.pop(0)
	return (int(diff / di[0]), int(di[0]))
T = int(input())
for t in range(T):
	s = input().split()
	n = int(s[0])
	x = int(s[1])
	y = int(s[2])
	diff = y - x
	divs = [1]
	d = 2
	while diff > 1:
		if diff % d == 0:
			divs.append(d)
			diff /= d
		else:
			d += 1
	(r, d) = findMinRD(divs, n)
	a = y - r * (n - 1)
	count = 0
	i = 0
	while count < n:
		w = a + r * i
		if w > 0:
			print(w, end=' ')
			count += 1
		i += 1
	print()


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
t = int(input())
for i in range(t):
	(n, x, y) = list(map(int, input().split()))
	a = y - x
	for j in range(n - 2, -1, -1):
		if a % (j + 1) == 0:
			temp = a // (j + 1)
			num = j + 1
			break
	ans = [x, y]
	for j in range(num - 1):
		ans.append(x + (j + 1) * temp)
	l = len(ans)
	p = n - l
	q = x // temp
	if x % temp == 0:
		q -= 1
	r = min(p, q)
	for j in range(r):
		ans.append(x - (j + 1) * temp)
	if p > q:
		p -= q
		for j in range(p):
			ans.append(y + (j + 1) * temp)
	print(' '.join((str(x) for x in ans)))


n = int(input())

def t(n, x, y):
	if n == 2:
		return [x, y]
	for z in range(1, y - x + 1):
		if (y - x) % z == 0:
			if (n - 1) * z >= y - x:
				koef = y // z
				start = y - min(koef, n - 1) * z
				if start == 0:
					start += z
				return [start + z * i for i in range(n)]
for _ in range(n):
	(n, x, y) = tuple(map(int, input().split()))
	print(*t(n, x, y))


import math
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	a = math.ceil((y - x) / (n - 1))
	b = y - x
	arr = []
	if b % a == 0 and b // a <= n - 1:
		initial = y
		while n != 0 and initial > 0:
			arr.append(initial)
			initial -= a
			n -= 1
		initial = y + a
		while n:
			arr.append(initial)
			initial += a
			n -= 1
	else:
		while b % a != 0 and b // a <= n - 1:
			a += 1
		initial = y
		while n != 0 and initial > 0:
			arr.append(initial)
			initial -= a
			n -= 1
		initial = y + a
		while n:
			arr.append(initial)
			initial += a
			n -= 1
	print(*arr)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	li = []
	if n == 2:
		print(x, y)
		continue
	xx = n - 1
	while True:
		if (y - x) % xx == 0:
			break
		xx -= 1
		if xx == 1:
			xx = 1
			break
	if xx == 1:
		xx = y - x
	else:
		xx = (y - x) // xx
	for i in range(x, y + 1, xx):
		li.append(i)
		n -= 1
	if n:
		x -= xx
		while x > 0 and n:
			li.append(x)
			n -= 1
			x -= xx
		y += xx
		while n:
			li.append(y)
			y += xx
			n -= 1
	print(*li)


from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush, heappop, heapify
import math
from collections import *
from functools import reduce, cmp_to_key
import sys
input = sys.stdin.readline
from itertools import accumulate
from functools import lru_cache
M = mod = 998244353

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

def inv_mod(n):
	return pow(n, mod - 2, mod)

def li():
	return [int(i) for i in input().rstrip('\n').split()]

def st():
	return input().rstrip('\n')

def val():
	return int(input().rstrip('\n'))

def li2():
	return [i for i in input().rstrip('\n')]

def li3():
	return [int(i) for i in input().rstrip('\n')]

def check(diff, x, y, n):
	s = set()
	i = y
	while n and i > 0:
		s.add(i)
		i -= diff
		n -= 1
	i = y + diff
	while n:
		n -= 1
		s.add(i)
		i += diff
	return -1 if x not in s else max(s)
for _ in range(val()):
	(n, x, y) = li()
	diff = factors(y - x)
	for i in range(1, y - x + 1):
		ans = check(i, x, y, n)
		if ans != -1:
			diff = i
			break
	l = []
	while n:
		l.append(ans)
		n -= 1
		ans -= diff
	print(*l)


def fun(n, k):
	l = []
	for i in range(1, n + 1):
		if n % i == 0:
			l.append(i)
	for x in l:
		if x >= k:
			return x
t = int(input())
for _ in range(t):
	ans = []
	(n, x, y) = map(int, input().split())
	if (y - x) % (n - 1) == 0:
		k = (y - x) // (n - 1)
	else:
		k = (y - x) // (n - 1) + 1
	d = fun(y - x, k)
	f = 0
	for i in range(x, y + 1, d):
		if len(ans) < n:
			ans.append(i)
		else:
			f = 1
			break
	if f == 1 or len(ans) == n:
		print(*ans)
	else:
		for i in range(x - d, 0, -d):
			if len(ans) < n:
				ans.append(i)
			else:
				f = 1
				break
		if f == 1 or len(ans) == n:
			print(*ans)
		else:
			c = y + d
			while len(ans) < n:
				ans.append(c)
				c += d
			print(*ans)


def solve():
	(n, x, y) = [int(v) for v in input().split()]
	arr = []
	for i in reversed(range(n - 1)):
		if (y - x) % (i + 1) == 0:
			diff = (y - x) // (i + 1)
			st = y - (n - 1) * diff
			while st <= 0:
				st += diff
			arr = [st]
			for _ in range(n - 1):
				arr.append(arr[-1] + diff)
			print(*arr)
			return
t = int(input())
for _ in range(t):
	solve()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	dif = y - x
	for i in range(1, dif + 1):
		if dif % i or dif // i + 1 > n:
			continue
		mul = min((y - 1) // i, n - 1)
		a = y - mul * i
		for j in range(n):
			print(a + j * i, end=' ')
		break
	print()


import math

def gen(n, first_elem, d):
	a = []
	for i in range(n):
		a.append(first_elem + i * d)
	return a
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	mx = None
	mx_a = None
	for d in range(1, 51):
		pos_dif = (y - x) / d
		pos_y = math.ceil(y / d)
		pos_x = math.ceil(x / d)
		if n > pos_dif == pos_y - pos_x and pos_x > 0:
			min_max = None
			first_elem = None
			if pos_y <= n:
				min_max = y + d * (n - pos_y)
				first_elem = y - d * (pos_y - 1)
			else:
				min_max = y
				first_elem = y - d * (n - 1)
			if mx is None:
				mx = min_max
				mx_a = gen(n, first_elem, d)
			elif mx > min_max:
				mx = min_max
				mx_a = gen(n, first_elem, d)
	print(*mx_a)


t = int(input())

def get_factors(n):
	factors = []
	for i in range(1, n + 1):
		if n % i == 0:
			factors.append(i)
	return factors
for _ in range(t):
	(n, x, y) = list(map(int, input().split()))
	diff = y - x
	factors = get_factors(diff)
	maximum = 0
	for factor in factors:
		if factor - 1 + 2 <= n:
			maximum = factor
	n_left = n - (maximum - 1 + 2)
	diff = diff // maximum
	final = [x, y]
	for i in range(1, maximum):
		final.append(x + i * diff)
	temp = x - diff
	while temp > 0 and n_left > 0:
		final.append(temp)
		n_left -= 1
		temp -= diff
	temp = y + diff
	while n_left > 0:
		final.append(temp)
		temp = temp + diff
		n_left -= 1
	for x in final:
		print(x, end=' ')
	print()


from collections import defaultdict as dd
from sys import stdin, stdout
from math import log
factors = [0]

def find():
	for i in range(1, 51):
		temp = []
		for j in range(1, i + 1):
			if i % j == 0:
				temp.append(j)
		factors.append(temp.copy())
find()
for t in range(int(input())):
	(n, x, y) = map(int, stdin.readline().strip().split())
	diff = y - x
	ans = []
	div = n - 1
	s = 1
	for i in factors[diff]:
		if i <= div:
			s = i
		else:
			break
	ans = [y]
	d = (y - x) // s
	n -= 1
	while n and ans[-1] - d > 0:
		ans.append(ans[-1] - d)
		n -= 1
	if n:
		ans.append(ans[0] + d)
		n -= 1
	while n:
		n -= 1
		ans.append(ans[-1] + d)
	print(*ans)


t = int(input())
for _ in range(t):
	(n, a, b) = map(int, input().split())
	sel = b - a
	d = 10000000.0
	for i in range(1, sel + 1):
		if sel % i == 0 and sel // i < n:
			for j in range(b, 100000, i):
				if j - (n - 1) * i > 0:
					if j < d:
						d = j
						r = i
						break
	ans = [d - r * i for i in range(n)]
	print(*ans)


def from_a_to_b(diff, a, b, ans):
	start = a
	while start <= b:
		ans.append(start)
		start += diff

def before_a(diff, a, b, ans, n):
	start = a - diff
	while start > 0 and len(ans) < n:
		ans.append(start)
		start -= diff

def after_b(diff, a, b, ans, n):
	start = b + diff
	while len(ans) < n:
		ans.append(start)
		start += diff

def solve(n, x, y):
	const = y - x
	diff = const // n
	if diff == 0:
		diff += 1
	while True:
		while const % diff != 0:
			diff += 1
		if const // diff + 1 <= n:
			break
		diff += 1
	ans = []
	from_a_to_b(diff, x, y, ans)
	if len(ans) < n:
		before_a(diff, x, y, ans, n)
	if len(ans) < n:
		after_b(diff, x, y, ans, n)
	return ans
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	ans = solve(n, x, y)
	for val in ans:
		print(val, end=' ')
	print('\n', end='')


def factors(a):
	l = []
	for i in range(1, a + 1):
		if a % i == 0:
			l.append(i)
	return l
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
		continue
	diff = y - x
	ans = []
	f_list = factors(diff)
	for i in f_list:
		q = diff // i
		if q + 1 <= n:
			break
	diff = diff // q
	ans.append(y)
	while ans[0] - diff > x:
		ans.insert(0, ans[0] - diff)
	while x > 0:
		ans.insert(0, x)
		x -= diff
	size = len(ans)
	while size < n:
		y += diff
		ans.append(y)
		size = len(ans)
	size -= n
	print(*ans[size:])


t = int(input())
for j in range(t):
	test = True
	d = 0
	(n, x, y) = map(int, input().split())
	l = []
	if test:
		for i in range(n - 1, 0, -1):
			if (y - x) % i == 0:
				d = (y - x) // i
				a = (y - x) // d + 1
				if a <= n:
					test = False
					break
	for i in range(x, y + 1, d):
		l.append(i)
	b = l[0]
	l.reverse()
	while b > 0 and len(l) < n:
		b -= d
		if b > 0:
			l.append(b)
	l.reverse()
	e = l[-1]
	while len(l) < n:
		e += d
		l.append(e)
	print(*l)


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 = 10 ** 9 + 7
mod2 = 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 IF(c, t, f):
	return t if c else f

def main():
	t = I()
	rr = []
	for _ in range(t):
		(n, x, y) = LI()
		s = y - x
		r = []
		for i in range(1, s + 1):
			if s % i != 0:
				continue
			if s // i >= n:
				continue
			for t in range(y, 0, -i):
				r.append(t)
				if len(r) == n:
					break
			for k in range(n - len(r)):
				r.append(y + i * (k + 1))
			break
		rr.append(JA(sorted(r), ' '))
	return JA(rr, '\n')
print(main())


def divisors(n):
	l = set()
	for i in range(1, n // 2 + 1):
		if n % i == 0:
			l.add(i)
			l.add(n // i)
	return list(l)

def main():
	for _ in range(int(input())):
		(n, x, y) = map(int, input().split())
		divs = divisors(y - x)
		temp = y - x
		for i in range(1, 10 ** 9):
			div = temp / i
			if div.is_integer() and div <= n - 1:
				break
		l = []
		div = int(div)
		term = x % i
		if term == 0:
			term = i
		else:
			term = x % i
		while term <= y:
			l.append(term)
			term += i
		size = n - len(l)
		if size > 0:
			for __ in range(size):
				l.append(term)
				term += i
		print(*l[-n:], sep=' ')
main()


T = int(input())
for t in range(T):
	nxy = list(map(int, input().split()))
	n = nxy[0]
	x = nxy[1]
	y = nxy[2]
	if n == 2:
		print(x, y)
		continue
	if (y - x) % (n - 1) == 0:
		d = (y - x) // (n - 1)
	else:
		d = (y - x) // (n - 1) + 1
	diff = y - x
	for i in range(d, y - x + 1):
		if (y - x) % i == 0:
			diff = i
			break
	li = []
	i = x
	s = 0
	while i != y + diff:
		li.append(i)
		i += diff
		s += 1
	flag = 0
	if s == n:
		flag = 1
	else:
		i = x - diff
		if i > 0:
			while i > 0 and flag == 0:
				li.append(i)
				i -= diff
				s += 1
				if n == s:
					flag = 1
					break
	i = y
	while flag == 0:
		i += diff
		li.append(i)
		s += 1
		if n == s:
			flag = 1
	for i in range(n):
		print(li[i], end=' ')
	print()


t = int(input())
for _ in range(t):
	(n, x, y) = [int(s) for s in input().split(' ')]
	minim = 1000000001
	out = []
	cop_n = n
	ans = ''
	if n == 2:
		print(x, y)
	else:
		diff = y - x
		i = diff
		while i > 0:
			if diff % i == 0:
				a = []
				curr = y
				n = cop_n
				while curr > x and n > 0:
					a.append(curr)
					n -= 1
					curr -= i
				if curr == x and n > 0:
					a.append(curr)
					n -= 1
					curr -= i
					while n > 0 and curr > 0:
						a.append(curr)
						n -= 1
						curr -= i
					curr = y + i
					while n > 0:
						a.append(curr)
						n -= 1
						curr += i
					if max(a) < minim:
						minim = max(a)
						out = a
			i -= 1
		for el in out:
			ans += str(el) + ' '
		print(ans[:-1])


t = int(input())
while t:
	(n, x, y) = map(int, input().split())
	l1 = []
	if y - n > 0:
		for i in range(1, 51):
			if y - i * n < x and (y - x) % i == 0:
				m = y
				count = n - 1
				while m > i and count > 0:
					m = m - i
					count = count - 1
				for j in range(0, n):
					l1.append(m)
					m = m + i
				break
	else:
		for i in range(1, n + 1):
			l1.append(i)
	print(*l1)
	t = t - 1


from __future__ import division, print_function
import os, sys
import math
import collections
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

class my_dictionary(dict):

	def __init__(self):
		self = dict()

	def add(self, key, value):
		self[key] = value

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

def si():
	return input()

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

def msi():
	return map(str, input().strip().split(' '))

def li():
	return list(mi())

def sli():
	return list(msi())

def dmain():
	sys.setrecursionlimit(100000000)
	threading.stack_size(40960000)
	thread = threading.Thread(target=main)
	thread.start()
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 getKey(item):
	return item[1]

def sort2(l):
	return sorted(l, key=getKey, reverse=True)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(n - r))

def binary_search(arr, low, high, x):
	if high >= low:
		mid = (high + low) // 2
		if arr[mid] == x:
			return mid
		elif arr[mid] > x:
			return binary_search(arr, low, mid - 1, x)
		else:
			return binary_search(arr, mid + 1, high, x)
	else:
		return -1

def ceil(x, y):
	if x % y == 0:
		return x // y
	else:
		return x // y + 1

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

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

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

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

def padded_bin_with_complement(x):
	if x < 0:
		return bin(2 ** 16 - abs(x))[2:].zfill(16)
	else:
		return bin(x)[2:].zfill(16)

def binaryToDecimal(binary):
	binary1 = binary
	(decimal, i, n) = (0, 0, 0)
	while binary != 0:
		dec = binary % 10
		decimal = decimal + dec * pow(2, i)
		binary = binary // 10
		i += 1
	print(decimal)

def CountFrequency(my_list):
	freq = {}
	for item in my_list:
		if item in freq:
			freq[item] += 1
		else:
			freq[item] = 1
	return freq

def pos(a):
	b = [0] * len(a)
	c = sorted(a)
	for i in range(len(a)):
		for j in range(len(a)):
			if c[j] == a[i]:
				b[i] = j
				break
	return b

def smallestDivisor(n):
	if n % 2 == 0:
		return 2
	i = 3
	while i * i <= n:
		if n % i == 0:
			return i
		i += 2
	return n

def commonn(a, b, n):
	c = []
	for i in range(n):
		if a[i] == b[i]:
			c.append('-1')
		else:
			c.append(b[i])
	return c

def find_lcm(num1, num2):
	if num1 > num2:
		num = num1
		den = num2
	else:
		num = num2
		den = num1
	rem = num % den
	while rem != 0:
		num = den
		den = rem
		rem = num % den
	gcd = den
	lcm = int(int(num1 * num2) / int(gcd))
	return lcm

def sumdigit(n):
	n = str(n)
	k = 0
	for i in range(len(n)):
		k += int(n[i])
	return k

def main():
	for _ in range(ii()):
		(n, x, y) = mi()
		diff = y - x
		for i in range(n - 1, 0, -1):
			if diff % i == 0:
				jk = diff // i
				break
		res = [x]
		l = 0
		r = n
		px = x
		while px - jk > 0:
			res.append(px - jk)
			px -= jk
		px = x
		for i in range(n - 1):
			res.append(px + jk)
			px += jk
		res.sort()
		for i in range(len(res) - 1, -1, -1):
			if i + 1 == n:
				r = i
				break
			elif res[i] == y:
				r = i
				break
		for i in range(len(res)):
			if r + 1 == n:
				break
			elif r - i == n - 1:
				l = i
				break
		print(*res[l:r + 1])
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')
main()


t = int(input())
for i in range(t):
	(n, x, y) = tuple(map(int, input().split()))
	space = y - x
	for gap in range(1, space + 1):
		if space % gap == 0 and gap * (n - 1) >= space:
			break
	if y - gap * (n - 1) > 0:
		print(*[y - i * gap for i in range(n)])
	else:
		start = x % gap
		if start == 0:
			start += gap
		print(*[start + i * gap for i in range(n)])


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	d = max(x, y) - min(x, y)
	m = n - 1
	f = 0
	a = [x, y]
	while m > 1:
		if d % m == 0:
			f = 1
			break
		else:
			m = m - 1
	c = 2
	if f == 1:
		p = min(x, y)
		q = max(x, y)
		m = d // m
		e = p + m
		while e < q and c < n:
			a.append(e)
			e = e + m
			c = c + 1
	else:
		m = d
	if c < n:
		p = min(x, y)
		e = p - m
		while e > 0 and c < n:
			a.append(e)
			e = e - m
			c = c + 1
	if c < n:
		p = max(x, y)
		e = p + m
		while c < n:
			a.append(e)
			e = e + m
			c = c + 1
	print(' '.join(map(str, a)))


from math import *
t = int(input())
for q in range(t):
	(n, a, b) = map(int, input().split())
	b1 = b
	for i in range(n - 1, 0, -1):
		if (b - a) % i == 0:
			d = int((b - a) / i)
			break
	last_list = []
	last_list.append(b)
	b -= d
	length = len(last_list)
	while b > 0 and length < n:
		last_list.append(b)
		b -= d
		length += 1
	b1 += d
	length = len(last_list)
	while length < n:
		last_list.append(b1)
		b1 += d
		length += 1
	print(*last_list)


test = int(input())
for t in range(0, test):
	(n, x, y) = [int(i) for i in input().split(' ')]
	d = y - x
	f = []
	for i in range(1, d + 1):
		if d % i == 0:
			f.append(i)
	me = 10 ** 20
	mi = d
	for e in f:
		alpha = x // e
		if x - alpha * e == 0:
			alpha -= 1
		afterY = n - alpha - 1 - d // e
		if afterY < 0:
			afterY = 0
		if d // e + 1 > n:
			continue
		if me > min(me, y + afterY * e):
			me = min(me, y + afterY * e)
			mi = e
	a = []
	for i in range(0, n):
		a.append(me - i * mi)
	a.sort()
	for e in a:
		print(e, end=' ')
	print()


R = lambda : map(int, input().split())
(t,) = R()
for _ in range(t):
	(n, x, y) = R()
	d = y - x
	i = 1
	while d % i or d // i >= n:
		i += 1
	x = max(x % i or i, y - n * i + i)
	print(*range(x, x + n * i, i))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	p = y - x
	d = p // n
	a = [x + i * d for i in range(n)]
	while y not in a:
		d += 1
		while p % d:
			d += 1
		a = [x + i * d for i in range(n)]
	r = x % d
	while 1:
		a = [r + i * d for i in range(n)]
		r += d
		if x in a and y in a and (0 not in a):
			break
	print(*a)


def answer(n, x, y):
	diff = y - x
	d = -1
	for i in range(n - 1, 0, -1):
		if diff % i == 0:
			d = diff // i
			break
	l = [y]
	q = y - d
	while len(l) < n and q > 0:
		l.append(q)
		q = q - d
	q = y + d
	while len(l) < n:
		l.append(q)
		q += d
	return l
t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	print(*answer(n, x, y))


import math
for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	dis = y - x
	tmp = n - 1
	while tmp != 0 and dis % tmp != 0:
		tmp -= 1
	step = dis / tmp if tmp != 0 else 0
	min_num = x - step * (n - tmp - 1) if x - step * (n - tmp - 1) > 0 else x - (math.ceil(x / step) - 1) * step
	for i in range(n):
		print(int(min_num + i * step), end=' ')
	print()


from math import *
for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	if x > y:
		(y, x) = (x, y)
	ma = -1
	ind = -1
	for a in range(1, 100):
		if (y - x) % a == 0 and (y - x) // a < n:
			if (y - x) // a + max(1, x // a) > ma:
				ma = (y - x) // a + max(1, x // a)
				ind = a
	v = [y - j * ind for j in range(n) if y - j * ind > 0]
	v += [y + j * ind for j in range(1, n - len(v) + 1)]
	print(*v)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	ct = 1
	for i in range(2, n):
		if diff % i == 0:
			ct = i
	we = diff // ct
	l = [x]
	n -= 1
	value = x
	while n > 0 and value + we <= y:
		l.append(value + we)
		value += we
		n -= 1
	value = x
	while n > 0 and value - we > 0:
		l.append(value - we)
		value -= we
		n -= 1
	value = y
	while n > 0:
		l.append(value + we)
		value += we
		n -= 1
	print(*l)


t = int(input())
for _ in range(t):
	(n, x, y) = [int(i) for i in input().split()]
	dis = 1
	for curl in range(n - 1, 0, -1):
		if not (y - x) % curl:
			dis = (y - x) // curl
			break
	one = x
	while one - dis > 0 and y <= one - dis + (n - 1) * dis:
		one -= dis
	print(one, end=' ')
	for i in range(n - 1):
		one += dis
		print(one, end=' ')
	print('')


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	mx = [999999999]
	for i in range(1, 51):
		for j in range(1, 51):
			l = [i + k * j for k in range(n)]
			if x in l and y in l and (l[-1] < mx[-1]):
				mx = l
	print(*mx)


for x in range(int(input())):
	(n, a, b) = list(map(int, input().split()))
	i = 1
	p = []
	k = b - a
	while i * i <= k:
		if k % i == 0:
			if k // i == i:
				p.append(i)
			else:
				p.extend([i, k // i])
		i += 1
	p.append(k)
	ans = []
	p.sort()
	for i in p:
		if k // i + 1 <= n:
			l = 0
			z = b
			while l < n:
				if b > 0:
					ans.append(b)
					b -= i
				else:
					break
				l += 1
			if l < n:
				while l < n:
					z += i
					ans.append(z)
					l += 1
			break
	print(*ans)


T = int(input())
for _ in range(T):
	(n, x, y) = map(int, input().split())
	D = []
	if n == 2:
		print(x, y)
		continue
	for a in range(1, x + 1):
		for d in range(1, 51):
			if (y - a) % d == 0 and (x - a) % d == 0 and (a + (n - 1) * d >= y):
				D.append([a, d, a + (n - 1) * d])
	l = D[0][2]
	a1 = D[0][0]
	d1 = D[0][1]
	if len(D) > 1:
		for i in range(1, len(D)):
			if D[i][2] < l:
				a1 = D[i][0]
				d1 = D[i][1]
				l = D[i][2]
	for i in range(n):
		if i == n - 1:
			print(a1 + i * d1)
		else:
			print(a1 + i * d1, end=' ')


import sys, bisect, string, math, time, functools, random, fractions
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
from itertools import permutations, combinations, groupby
rep = range
R = range

def Golf():
	(n, *t) = map(int, open(0).read().split())

def I():
	return int(input())

def S_():
	return input()

def IS():
	return input().split()

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

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

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

def LI_():
	return [int(i) - 1 for i in input().split()]

def NI(n):
	return [int(input()) for i in range(n)]

def NI_(n):
	return [int(input()) - 1 for i in range(n)]

def NLI(n):
	return [[int(i) for i in input().split()] for i in range(n)]

def NLI_(n):
	return [[int(i) - 1 for i in input().split()] for i in range(n)]

def StoLI():
	return [ord(i) - 97 for i in input()]

def ItoS(n):
	return chr(n + 97)

def LtoS(ls):
	return ''.join([chr(i + 97) for i in ls])

def RA():
	return map(int, open(0).read().split())

def RLI(n=8, a=1, b=10):
	return [random.randint(a, b) for i in range(n)]

def RI(a=1, b=10):
	return random.randint(a, b)

def Rtest(T):
	(case, err) = (0, 0)
	for i in range(T):
		inp = INP()
		(a1, ls) = naive(*inp)
		a2 = solve(*inp)
		if a1 != a2:
			print((a1, a2), inp)
			err += 1
		case += 1
	print('Tested', case, 'case with', err, 'errors')

def GI(V, E, ls=None, Directed=False, index=1):
	org_inp = []
	g = [[] for i in range(V)]
	FromStdin = True if ls == None else False
	for i in range(E):
		if FromStdin:
			inp = LI()
			org_inp.append(inp)
		else:
			inp = ls[i]
		if len(inp) == 2:
			(a, b) = inp
			c = 1
		else:
			(a, b, c) = inp
		if index == 1:
			a -= 1
			b -= 1
		aa = (a, c)
		bb = (b, c)
		g[a].append(bb)
		if not Directed:
			g[b].append(aa)
	return (g, org_inp)

def GGI(h, w, search=None, replacement_of_found='.', mp_def={'#': 1, '.': 0}, boundary=1):
	mp = [boundary] * (w + 2)
	found = {}
	for i in R(h):
		s = input()
		for char in search:
			if char in s:
				found[char] = (i + 1) * (w + 2) + s.index(char) + 1
				mp_def[char] = mp_def[replacement_of_found]
		mp += [boundary] + [mp_def[j] for j in s] + [boundary]
	mp += [boundary] * (w + 2)
	return (h + 2, w + 2, mp, found)

def TI(n):
	return GI(n, n - 1)

def accum(ls):
	rt = [0]
	for i in ls:
		rt += [rt[-1] + i]
	return rt

def bit_combination(n, base=2):
	rt = []
	for tb in R(base ** n):
		s = [tb // base ** bt % base for bt in R(n)]
		rt += [s]
	return rt

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

def YN(x):
	print(['NO', 'YES'][x])

def Yn(x):
	print(['No', 'Yes'][x])

def show(*inp, end='\n'):
	if show_flg:
		print(*inp, end=end)
mo = 10 ** 9 + 7
inf = float('inf')
FourNb = [(-1, 0), (1, 0), (0, 1), (0, -1)]
EightNb = [(-1, 0), (1, 0), (0, 1), (0, -1), (1, 1), (-1, -1), (1, -1), (-1, 1)]
compas = dict(zip('WENS', FourNb))
cursol = dict(zip('LRUD', FourNb))
l_alp = string.ascii_lowercase
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
input = lambda : sys.stdin.readline().rstrip()
show_flg = False
show_flg = True
ans = 0
for _ in range(I()):
	ans = 0
	(n, x, y) = LI()
	d = y - x
	for i in range(1, d + 1):
		if d % i != 0 or d // i + 1 > n:
			continue
		else:
			k = i
			ans = i
			break
	r = n - (d // k + 1)
	s = max((x - 1) // k, 0)
	if r >= s:
		m = x - s * k
	else:
		m = x - r * k
	ans = list(range(m, m + n * k, k))
	print(*ans)


t = int(input())
for _ in range(t):
	[n, a, b] = [int(x) for x in input().split()]
	nGaps = n - 1
	diff = b - a
	while nGaps > 1:
		if diff % nGaps == 0:
			break
		nGaps -= 1
	nEle = nGaps - 1
	apDiff = diff // nGaps
	count = 2
	arr = [a, b]
	curr = a
	nEleBetween = 0
	while curr + apDiff < b:
		arr.append(curr + apDiff)
		curr += apDiff
		n -= 1
	n -= 2
	curr = a
	while n > 0 and curr - apDiff >= 1:
		curr -= apDiff
		arr.append(curr)
		n -= 1
	while n > 0:
		arr.append(b + apDiff)
		b += apDiff
		n -= 1
	for i in arr:
		print(i, end=' ')
	print()


from sys import stdin, stdout

class SOLVE:

	def solve(self):
		R = stdin.readline
		W = stdout.write
		ans = []
		for i in range(int(input())):
			(n, x, y) = [int(x) for x in R().split()]
			gap = None
			for i in range(n - 1, 0, -1):
				if (y - x) % i == 0:
					gap = (y - x) // i
					break
			ans += [str(y)]
			n -= 1
			temp = y - gap
			while temp > 0 and n > 0:
				ans += [' ' + str(temp)]
				n -= 1
				temp -= gap
			temp = y + gap
			while n > 0:
				ans += [' ' + str(temp)]
				n -= 1
				temp += gap
			ans += ['\n']
		W(''.join(ans))

def main():
	s = SOLVE()
	s.solve()
main()


def factor(c):
	list = []
	for i in range(1, c + 1):
		if c % i == 0:
			list.append(i)
	return list
game = int(input())
for i in range(game):
	(n, x, y) = list(map(int, input().split()))
	d = factor(y - x)
	final = 0
	z = 0
	for value in d:
		if final == y:
			break
		for i in range(1, n):
			if y - i * value == x:
				final = y
				z = value
				break
	a = y
	for i in range(1, n):
		if a > z:
			a = y - i * z
		else:
			break
	for i in range(n):
		print(a + i * z, end=' ')


testcases = int(input())
for test in range(testcases):
	(n, x, y) = map(int, input().split())
	div = (y - x) // (n - 1)
	if n > 2:
		if (y - x) % (n - 1) == 0:
			anss = []
			for a in range(x, y + div, div):
				anss.append(a)
			print(*anss)
		else:
			ans = []
			min = 1
			while (y - x) % (n - min) != 0:
				min = min + 1
			d = (y - x) // (n - min)
			for a in range(x, y + d, d):
				ans.append(a)
			start = x
			last = y
			while len(ans) != n:
				if start - d > 0:
					start = start - d
					ans.append(start)
				else:
					last = last + d
					ans.append(last)
			print(*ans)
	else:
		print('{} {}'.format(x, y))


rw = int(input())
for wewq in range(rw):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
		continue
	a = []
	for i in range(1, 50):
		if (y - x) % i == 0 and (y - x) // i + 1 <= n:
			p = i
			break
	a = [y]
	i = 0
	while i < n - 1 and a[i] >= 1 + p:
		a.append(a[i] - p)
		i += 1
	a.sort()
	while i < n - 1:
		a.append(a[i] + p)
		i += 1
	for i in a:
		print(i, end=' ')
	print('')


for _ in range(int(input())):
	(n, x, y) = [int(x) for x in input().split()]
	t = n
	diff = y - x
	n -= 1
	while diff % n != 0:
		n -= 1
	k = diff // n
	ss = 0
	for i in range(x, y + 1, k):
		print(i, end=' ')
		ss += 1
	while ss < t and x - k > 0:
		print(x - k, end=' ')
		x -= k
		ss += 1
	while ss < t:
		print(y + k, end=' ')
		y += k
		ss += 1
	print()


for _ in range(int(input())):
	(n, x, y) = [int(x) for x in input().split()]
	d = y - x
	d1 = []
	for i in range(1, d + 1):
		if d % i == 0:
			d1.append(i)
	for i in range(len(d1)):
		y1 = int(str(y))
		l = [y1]
		c = 1
		while y1 - d1[i] >= 1 and c < n:
			y1 -= d1[i]
			l.append(y1)
			c += 1
		if c == n and x in l:
			print(*l)
			break
		elif c < n and x in l:
			k1 = int(str(y))
			while c < n:
				k1 += d1[i]
				l.append(k1)
				c += 1
			print(*l)
			break


import math
for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	d = b - a
	s = 1
	while d % s > 0 or d // s + 1 > n:
		s += 1
	step = s
	ans = list(range(a, b + 1, step))
	while len(ans) < n:
		a -= step
		if a <= 0:
			break
		ans.append(a)
	while len(ans) < n:
		b += step
		ans.append(b)
	print(' '.join(map(str, ans)))


import math
from collections import deque
from sys import stdin, stdout
from string import ascii_letters
import sys
letters = ascii_letters
input = stdin.readline
print = stdout.write
for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = y - x
	res = (d, 99999999999999)
	for i in range(1, y + 1):
		if d % i == 0 and d // i + 1 <= n:
			step = i
			have = d // step + 1
			before = min(n - have, x // step)
			if before * step >= x:
				before -= 1
			mx = x - before * step + n * step
			if mx < res[1]:
				res = (step, mx)
	have = d // res[0] + 1
	before = min(n - have, x // res[0])
	if before * res[0] >= x:
		before -= 1
	for i in range(x - before * res[0], x - before * res[0] + n * res[0], res[0]):
		print(str(i) + ' ')
	print('\n')


import math, sys
from collections import defaultdict, Counter, deque
INF = float('inf')
MOD = 10 ** 9 + 7

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def isPrime(n):
	if n <= 1:
		return False
	i = 2
	while i ** 2 <= n:
		if n % i == 0:
			return False
		i += 1
	return True

def primeFactors(n):
	factors = defaultdict(int)
	i = 2
	while i ** 2 <= n:
		while n % i == 0:
			factors[i] += 1
			n //= i
		i += 1
	if n > 1:
		factors[n] += 1
	return factors

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

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

def a():
	(a, b) = map(int, input().split())
	ans = math.ceil(abs(b - a) / 10)
	print(ans)

def b():
	(a, b, x, y, n) = vars()
	(n1, n2) = (n, n)
	a1 = a - min(a - x, n)
	b2 = b - min(b - y, n)
	n1 -= a - a1
	n2 -= b - b2
	b1 = b - min(b - y, n1)
	a2 = a - min(a - x, n2)
	print(min(a1 * b1, a2 * b2))

def c():
	(n, x, y) = vars()
	diff = None
	ans = None
	for d in range(1, y - x + 1):
		arr = []
		num = x
		while num <= y:
			arr.append(num)
			num += d
		if len(arr) <= n and x in arr and (y in arr):
			diff = d
			break
	for start in range(1, x + 1):
		ans = []
		num = start
		for i in range(n):
			ans.append(num)
			num += diff
		if x in ans and y in ans:
			print(*ans)
			return
t = 1
t = int(input())
for _ in range(t):
	c()


cases = int(input())
for i in range(cases):
	(n, x, y) = map(int, input().split())
	mindivider = None
	minNum = None
	if n == 1:
		print(x, y)
		continue
	for k in range(n - 1, 0, -1):
		if (y - x) % k == 0:
			mindivider = k
			minNum = (y - x) // k
			break
	result = []
	result.append(x)
	result.append(y)
	count = 2
	newcount = 0
	if mindivider == 1:
		pass
	else:
		for k in range(mindivider - 1):
			newcount += 1
			result.append(x + minNum * newcount)
			count += 1
	newcount = 0
	adder = 1
	while count < n and adder > 0:
		newcount += 1
		adder = x - newcount * minNum
		if adder > 0:
			result.append(adder)
			count += 1
		else:
			break
	newcount = 0
	while count < n:
		newcount += 1
		count += 1
		result.append(y + newcount * minNum)
	for x in result:
		print(x, end=' ')


def calc(p, n):
	j = 1
	d = 100000
	while j * j <= p:
		if p % j == 0:
			if p // j <= n - 1:
				d = min(d, j)
			if j <= n - 1:
				d = min(d, p // j)
		j += 1
	return d
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	p = y - x
	t = 0
	c = 0
	f = []
	d = calc(p, n)
	while t < n and x + c * d <= y:
		f.append(x + c * d)
		c += 1
		t += 1
	c = 1
	while t < n and x - c * d >= 1:
		f.append(x - c * d)
		t += 1
		c += 1
	c = 1
	while t < n:
		f.append(y + c * d)
		t += 1
		c += 1
	print(*f)


for i in range(int(input())):
	(n, x, y) = (int(j) for j in input().split())
	ans = [10 ** 18 for j in range(n)]
	for j in range(n):
		for k in range(n):
			if not j < k:
				continue
			dn = k - j
			if (y - x) % dn == 0:
				d = (y - x) // dn
				tmp_ans = [0 for h in range(n)]
				tmp_ans[0] = x - j * d
				for h in range(1, n):
					tmp_ans[h] = tmp_ans[h - 1] + d
				if tmp_ans[0] > 0 and tmp_ans[n - 1] < ans[n - 1]:
					ans = tmp_ans
	print(' '.join((str(j) for j in ans)))


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	l = n
	d = y - x
	m = 1
	n = n - 2
	for j in range(1, n + 1):
		if d % (j + 1) == 0:
			m = j + 1
	m = int(d / m)
	a = [x, y]
	t = x + m
	while n > 0 and t < y:
		a.append(t)
		t = t + m
		n = n - 1
	t = x - m
	while n > 0 and t > 0:
		a.append(t)
		t = t - m
		n = n - 1
	t = y + m
	while n > 0:
		a.append(t)
		t = t + m
		n = n - 1
	for k in range(l):
		print(a[k], ' ', end='', sep='')
	print()


import math
for _ in range(int(input())):
	l = []
	(n, x, y) = list(map(int, input().split()))
	n -= 2
	l.append(x)
	l.append(y)
	copy = n + 1
	diff = abs(x - y)
	while copy != 0:
		if abs(x - y) % copy == 0:
			diff = abs(x - y) // copy
			break
		copy -= 1
	present = min(x, y) + diff
	while n != 0 and present < max(x, y):
		l.append(present)
		present += diff
		n -= 1
	present = min(x, y) - diff
	while n != 0 and present > 0:
		l.append(present)
		present -= diff
		n -= 1
	present = max(x, y) + diff
	while n != 0:
		l.append(present)
		present += diff
		n -= 1
	print(*l)


t = int(input())
for i in range(t):
	str = ''
	nums = list(map(int, input().split()))
	n = nums[0]
	x = nums[1]
	y = nums[2]
	dif = y - x
	if n == 2:
		print(f'{x} {y}')
	else:
		rem = dif % (n - 1)
		if rem == 0:
			mul = dif / (n - 1)
			arr = [y - mul * i for i in range(n)]
			for num in arr:
				str += f'{int(num)} '
		else:
			count = 0
			num = y
			btw = n - 1
			while btw >= 1:
				mul = int(y - x) / btw
				if mul == int(mul):
					break
				btw -= 1
			while num > 0 and count < n:
				str += f'{int(num)} '
				num -= mul
				count += 1
			num = y + mul
			while count < n:
				str += f'{int(num)} '
				num += mul
				count += 1
		print(str)


for _ in range(int(input())):
	(n, x, y) = [int(x) for x in input().split()]
	diff = y - x
	maxs = n - 1
	l = maxs
	while l > 1:
		if diff % l == 0:
			break
		l -= 1
	d = diff // l
	b = min((x - 1) // d, n - (l + 1))
	a = x - b * d
	for i in range(n):
		print(a + i * d, end=' ')
	print()


import sys
input = sys.stdin.readline
T = int(input())
for _ in range(T):
	(n, x, y) = map(int, input().split())
	ans = sys.maxsize
	n = n - 1
	flag = 0
	for i in range(n):
		for j in range(n - i):
			k = n - i - j - 1
			diff = y - x
			if j == 0:
				p = diff
			else:
				p = diff / (j + 1)
			if float(p).is_integer():
				max_n = y + p * i
				min_n = x - p * k
			if min_n >= 1:
				flag = 1
				break
		if flag == 1:
			break
	(min_n, max_n, p) = (int(min_n), int(max_n), int(p))
	print(*list(range(min_n, max_n + p, p)))


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	n1 = n
	j = 0
	l = []
	for i in range(1, y - x + 1):
		xx = (y - x) / i
		if xx == int(xx) and int(xx) + 1 <= n:
			j = i
			break
	n -= (y - x) // j + 1
	for i in range(x, y + 1, j):
		l.append(i)
	i = x - j
	while i > 0 and len(l) < n1:
		l.append(i)
		i -= j
	n -= (x - 1) // j
	if n > 0:
		for i in range(1, n + 1):
			l.append(y + i * j)
	print(*l)


t = int(input())
while t > 0:
	t -= 1
	(n, x, y) = [int(x) for x in input().split()]
	k = [x for x in range(1, n)]
	for i in reversed(k):
		if (y - x) % i == 0:
			cd = (y - x) // i
			break
	arr = []
	ans = y
	ans1 = y
	while ans > 0 and len(arr) < n:
		arr.append(ans)
		ans -= cd
	while len(arr) < n:
		ans1 += cd
		arr.append(ans1)
	arr.sort()
	print(*arr)


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	difference = y - x
	answers = []
	for diff in range(1, difference + 1):
		if difference % diff == 0:
			ans = []
			for i in range(y, x - 1, -(difference // diff)):
				ans.append(i)
			if len(ans) == n:
				answers.append(ans)
			elif len(ans) < n:
				for i in range(x - difference // diff, 0, -difference // diff):
					if len(ans) < n:
						ans.append(i)
					else:
						break
				if len(ans) == n:
					answers.append(ans)
				else:
					for i in range(y + difference // diff, 10 ** 9 + 1, difference // diff):
						if len(ans) < n:
							ans.append(i)
						else:
							break
					answers.append(ans)
	print(*min(answers, key=lambda x: max(x)))


def checker(d, k, n):
	if d % k:
		return False
	d = d // k
	if d + 1 <= n:
		return True
	return False

def sol(n, x, y):
	if n <= 2:
		print(x, y)
		return
	(x, y) = (max(x, y), min(x, y))
	m = x - y
	k = 0
	l = 0
	for i in range(1, n + 1):
		if m % i == 0 and checker(m, m // i, n):
			k = i
	dif = m // k
	diff = dif
	data = [y]
	while data[-1] != x:
		data.append(data[-1] + dif)
	x = data[0] - dif
	while x > 0 and len(data) < n:
		data.insert(0, x)
		x = x - diff
	x = data[-1] + dif
	while len(data) < n:
		data.append(x)
		x += diff
	print(*data)
k = int(input())
for i in range(k):
	(n, x, y) = list(map(int, input().split(' ')))
	sol(n, x, y)


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	term = 0
	finalmax = 10000000000
	mx = 0
	for j in range(n - 1, 0, -1):
		gan = j
		if (y - x) % gan == 0:
			if y - (y - x) // gan * (n - 1) <= 0:
				mx = y + (abs(y - (y - x) // gan * (n - 1)) // ((y - x) // gan) + 1) * ((y - x) // gan)
			else:
				mx = y
			if finalmax > mx:
				finalmax = mx
				term = (y - x) // gan
	if n != 2:
		line = []
		for j in range(n):
			if j != n - 1:
				print(finalmax - j * term, end=' ')
			else:
				print(finalmax - j * term)
	else:
		print(x, y)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	m = 53
	d = y - x
	flag = 0
	for i in range(1, d + 1):
		val = d // i - 1
		if d % i != 0 or val > n - 2:
			continue
		if val == n - 2:
			temp = x
			while x <= y:
				print(x, end=' ')
				x += i
			print()
			flag = 1
			break
		m = min(m, i)
	val = y
	if flag == 0:
		while n > 0 and val > 0:
			print(val, end=' ')
			n -= 1
			val -= m
		while n > 0:
			print(y + m, end=' ')
			y += m
			n -= 1
		print()


def solve(n, x, y):
	maxi = 49
	for i in range(51, 0, -1):
		diff = i
		if (y - x) % diff != 0:
			continue
		if n < (y - x) // diff + 1:
			break
		maxi = min(maxi, diff)
	ans = [x, y]
	n -= 2
	temp = x
	while n > 0:
		while temp + maxi < y:
			ans.append(temp + maxi)
			temp += maxi
			n -= 1
		temp = x
		while temp - maxi > 0 and n > 0:
			ans.append(temp - maxi)
			temp -= maxi
			n -= 1
		temp = y
		while n > 0:
			ans.append(temp + maxi)
			temp += maxi
			n -= 1
	print(' '.join(map(str, ans)))
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	solve(n, x, y)


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	dif = abs(x - y)
	val = n - 1
	inside = 0
	md = dif
	li = [x, y]
	r = y
	l = x
	left = x
	while val > 1:
		if dif % val == 0:
			md = int(dif / val)
			inside = int(dif / md - 1)
			break
		else:
			val = val - 1
	for i in range(inside):
		left = left + md
		li.append(left)
	rem = n - inside - 2
	while l - md > 0 and rem > 0:
		li.append(l - md)
		l = l - md
		rem = rem - 1
	while rem > 0:
		li.append(r + md)
		r = r + md
		rem = rem - 1
	for ele in li:
		print(ele, end=' ')
	print()


from sys import stdin, stdout
test = int(stdin.readline())
for _ in range(test):
	(n, a, b) = map(int, stdin.readline().split())
	if n == 2:
		print(a, b)
		continue
	diff = b - a
	ans = 1
	for i in range(1, n):
		if not diff % i:
			ans = i
	r = diff // ans
	arr = [a + r * i for i in range(ans + 1)]
	rest = n - ans - 1
	temp = a - r
	na = []
	while temp > 0 and rest > 0:
		na.append(temp)
		temp -= r
		rest -= 1
	ans = na[::-1] + arr[:]
	temp = b + r
	while rest > 0:
		ans.append(temp)
		temp += r
		rest -= 1
	print(*ans)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = []
	for i in range(1, 50):
		if (y - x) % i == 0:
			d.append(i)
	ans = []
	for i in range(1, x + 1):
		for j in d:
			a = []
			for k in range(n):
				a.append(i + k * j)
			if x in a and y in a:
				ans.append(a)
	mx = max(ans[0])
	ind = 0
	for i in range(1, len(ans)):
		if max(ans[i]) < mx:
			mx = max(ans[i])
			ind = i
	for i in range(n):
		print(ans[ind][i], end=' ')
	print()


def main():
	T = int(input())
	for _ in range(T):
		(n, x, y) = (int(i) for i in input().split())
		ans = []
		ans_max = 10 ** 12
		for start in range(1, 50):
			for d in range(1, 50):
				A = [start + i * d for i in range(n)]
				if x not in A or y not in A:
					continue
				maxA = max(A)
				if maxA < ans_max:
					ans = A
					ans_max = maxA
		print(*ans)
main()


def schet():
	string = input()
	(n, x, y) = list(map(int, string.split()))
	arr = []
	if n == 2:
		arr.append(x)
		arr.append(y)
		print(*arr)
	else:
		temp = n
		while (y - x) % (temp - 1) != 0 and temp > 1:
			temp -= 1
		shag = (y - x) // (temp - 1)
		new_y = y
		arr.append(new_y)
		for i in range(n - 1):
			if new_y - shag > 0:
				new_y -= shag
				arr.append(new_y)
			else:
				y += shag
				arr.append(y)
		print(*arr)
t = int(input())
for i in range(t):
	schet()


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	M = 10 ** 18
	D = -1
	for d in range(1, y - x + 1):
		if (y - x) % d == 0 and (y - x) // d <= n - 1:
			nokori = n - 1 - (y - x) // d
			f = x
			while nokori > 0 and f - d > 0:
				nokori -= 1
				f -= d
			e = y + nokori * d
			if M > e:
				M = e
				D = d
	print(*[M - i * D for i in range(n)])


try:
	for k in range(int(input())):
		(n, x, y) = map(int, input().split())
		dif = y - x
		for j in range(n - 1, 0, -1):
			if dif % j < 1:
				break
		f = dif // j
		s = max(y - (n - 1) * f, (y - 1) % f + 1)
		print(*range(s, s + f * n, f))
except:
	pass


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	mini = 10 ** 9 + 2
	dif = 1
	f = 1
	for a in range(1, x):
		for d in range(1, x):
			if (x - a) % d == 0 and (y - a) % d == 0:
				m = (y - a) // d
				if m < n and mini > a + (n - 1) * d:
					mini = a + (n - 1) * d
					f = a
					dif = d
	for d in range(1, y - x + 1):
		if (y - x) % d == 0:
			m = (y - x) // d
			if m < n and mini > x + (n - 1) * d:
				mini = x + (n - 1) * d
				f = x
				dif = d
	for i in range(n):
		print(f + i * dif, end=' ')
	print()


def factor(N):
	arr = []
	for i in range(1, int(N ** 0.5) + 1):
		if N % i == 0:
			arr.append(i)
			if N // i != i:
				arr.append(N // i)
	return arr

def solve():
	(n, x, y) = map(int, input().split())
	fac = factor(y - x)
	res = 10 ** 30
	ans = []
	for d in fac:
		li = []
		N = n
		Y = y
		while Y > 0 and N > 0:
			li.append(Y)
			N -= 1
			Y -= d
		Y = y + d
		while N > 0:
			li.append(Y)
			N -= 1
			Y += d
		m = max(li)
		if x in li and y in li and (m < res) and (len(li) == n):
			ans = li.copy()
			res = m
	return ans
t = int(input())
for _ in range(t):
	print(*solve())


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	zc = y - x
	if zc % (n - 1) == 0:
		cd = zc // (n - 1)
		for i in range(x, y + 1, cd):
			print('%d ' % i, end='')
		print()
	else:
		for i in range(n - 1, 0, -1):
			if (y - x) % i == 0:
				break
		cd = (y - x) // i
		sl = 0
		for i in range(y, 0, -cd):
			if sl == n:
				break
			sl += 1
			print('%d ' % i, end='')
		for i in range(y + cd, 10 ** 18, cd):
			if sl == n:
				break
			print('%d ' % i, end='')
			sl += 1
		print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	li = []
	zi = [x]
	d = 1000000
	for i in range(n, 1, -1):
		d = float((y - x) / (i - 1))
		if d.is_integer():
			for ii in range(i - 1):
				zi.append(zi[-1] + int(d))
			break
	val = x
	while len(zi) < n:
		val -= d
		if val <= 0:
			break
		else:
			zi.append(int(val))
	val = y
	while len(zi) < n:
		val += d
		zi.append(int(val))
	zi.sort()
	print(*zi)


import sys
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = 10 ** 18
	(ft, CD) = (0, 0)
	for i in range(1, n):
		for j in range(i + 1, n + 1):
			d = y - x
			if d % (j - i) == 0:
				cd = d // (j - i)
				fst = x - (i - 1) * cd
				lst = fst + (n - 1) * cd
				if lst < ans and fst > 0:
					ft = fst
					CD = cd
					ans = lst
	for i in range(n):
		print(ft, end=' ')
		ft += CD
	print('')


import sys
pprint = lambda s: print(' '.join(map(lambda x: str(x), s)))
input = lambda : sys.stdin.readline().strip()
ipnut = input
mod = 1000000007
for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = y - x
	l = []
	for i in range(d):
		if d % (i + 1) == 0:
			l.append(i + 1)
	h = 0
	for i in l:
		if x + (n - 1) * i >= y:
			start = max((x - 1) % i + 1, y - (n - 1) * i)
			h = i
			break
		else:
			continue
	for i in range(n):
		print(start, end=' ')
		start += h
	print()


T = int(input())
for case in range(T):
	(n, x, y) = map(int, input().split())
	k = abs(x - y)
	for i in range(1, 51):
		if k % i != 0 or k / i >= n:
			continue
		g = i
		break
	for i in range(x, y + 1, g):
		print(i, end=' ')
		n -= 1
	for i in range(x - g, 0, -g):
		if n == 0:
			break
		print(i, end=' ')
		n -= 1
	for i in range(y + g, 10000000, g):
		if n == 0:
			break
		print(i, end=' ')
		n -= 1
	print()


t = int(input())
for j in range(t):
	(n, x, y) = [int(k) for k in input().split()]
	if n >= y:
		for i in range(1, n + 1):
			print(i, end=' ')
		print('')
	else:
		p = n - 1
		while p > 0:
			if (y - x) % p == 0:
				break
			p -= 1
		cd = (y - x) // p
		left = n - p - 1
		while left > 0 and x >= 1:
			x -= cd
			left -= 1
		if x < 1:
			x += cd
		for i in range(n):
			print(x + i * cd, end=' ')
		print('')


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	a = []
	p = y - x
	if n == 2:
		print(x, y)
	else:
		for i in range(n - 1, 0, -1):
			if p % i == 0:
				t = p // i
				x = x - t * (n - i - 1)
				for j in range(n):
					a.append(x + t * j)
				break
		for i in range(n):
			if a[i] <= 0:
				a[i] = a[-1] + t * (i + 1)
			else:
				break
		print(*a)


for _ in range(int(input())):
	xxx = 0
	jjj = 1
	lsttt = [0, 0, 0, 0, 0, 0]
	ddd = False
	(n, x, y) = map(int, input().split())
	m = 100000000000
	for i in range(1, n):
		if (y - x) % i == 0:
			diff = (y - x) // i
			ddd = True
			xxx += 1
		m = min(m, diff)
	diff = m
	a = [x, y]
	for i in range(x + diff, y, diff):
		if len(a) == n:
			break
		a.append(i)
	if len(a) < n:
		m = min((x - 1) // diff, n - len(a))
		temp = x - diff
		ddd = False
		for i in range(m):
			a.append(temp)
			temp -= diff
	if len(a) < n:
		i = y + diff
		while True:
			if len(a) == n:
				ddd = True
				break
			a.append(i)
			i += diff
	for i in a:
		print(i, end=' ')
	print('')


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	a = y - x
	common_diff = 0
	arr = []
	for i in range(1, n):
		if a % (n - i) == 0:
			common_diff = a // (n - i)
			break
	c = False
	l = n
	for i in range(n):
		b = y - i * common_diff
		if b > 0:
			arr.append(b)
		else:
			c = True
			l -= i
			break
	if c:
		for i in range(1, l + 1):
			b = y + i * common_diff
			arr.append(b)
	print(*arr)


t = int(input())
while t:
	(n, x, y) = map(int, input().split())
	ans = list()
	sub = y - x
	st = list()
	for i in range(1, int(sub ** 0.5) + 1):
		if sub % i == 0:
			st.append(i)
			st.append(sub // i)
	st.sort()
	for i in st:
		num = 0
		tmp = list()
		val = y
		while val >= 1 and num < n:
			tmp.append(val)
			val -= i
			num += 1
		if val < 1:
			val = y + i
			while num < n:
				tmp.append(val)
				val += i
				num += 1
		if num == n and x in tmp:
			ans = tmp
			break
	for i in ans:
		print(i, end=' ')
	print()
	t -= 1


def create(n, x, d):
	l = []
	while n:
		l.append(x)
		x += d
		n -= 1
	return l
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	l = []
	diff = y - x
	for i in range(n - 1, 0, -1):
		if diff % i == 0:
			minDown = min((x - 1) // (diff // i), n - i - 1)
			x -= minDown * (diff // i)
			print(*create(n, x, diff // i))
			break


testCases = int(input(''))
for i in range(0, testCases):
	user = input('')
	data = user.split(' ')
	finalValues = []
	jumpList = []
	n = int(data[0])
	x = int(data[1])
	y = int(data[2])
	if x < y:
		smallerNum = x
		largerNum = y
	else:
		smallerNum = y
		largerNum = x
	diff = largerNum - smallerNum
	for i in range(1, n):
		for j in range(i + 1, n + 1):
			jumps = j - i
			if diff % jumps == 0:
				jumpDiff = diff / jumps
				if smallerNum - jumpDiff * (i - 1) >= 1:
					finalValue = smallerNum + (n - i) * jumpDiff
					finalValues.append(int(finalValue))
					jumpList.append(int(jumpDiff))
			elif jumps > diff:
				break
	least = 0
	for i in range(1, len(finalValues)):
		if finalValues[i] < finalValues[least]:
			least = i
	startingNum = finalValues[least] - (n - 1) * jumpList[least]
	allValues = []
	for i in range(1, n + 1):
		allValues.append(startingNum + jumpList[least] * (i - 1))
	print(*allValues, sep=' ')


from sys import stdin
import math
for _ in range(int(stdin.readline())):
	(n, x, y) = list(map(int, stdin.readline().split()))
	t = math.ceil((y - x) / (n - 1))
	gap = 1
	for i in range(t, y - x + 1):
		if (y - x) % i == 0:
			gap = i
			break
	res = list(range(y, max(0, y - gap * (n - 1) - 1), -gap))
	r = n - len(res)
	res += list(range(y + gap, y + gap * r + 1, gap))
	print(*res)


def find(num, n):
	if num < n:
		return 1
	for i in range(2, num // 2 + 1):
		if num % i == 0 and num // i <= n - 1:
			return i
	return num

def func(n, x, y):
	big = y
	small = x
	if big - small + 1 == n:
		print(*range(small, big + 1))
		return
	num = big - small
	i = find(num, n)
	length = n
	arr = list(range(small, big + 1, i))
	length -= len(arr)
	while small >= 1 and length != 0:
		small = small - i
		if small <= 0:
			break
		arr.append(small)
		length -= 1
	while length != 0:
		big += i
		arr.append(big)
		length -= 1
	print(*arr)
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	func(n, x, y)


t = int(input())
while t:
	t = t - 1
	(n, x, y) = map(int, input().split())
	diff = y - x
	for i in range(1, diff + 1):
		if diff % i == 0:
			if diff // i < n:
				gap = i
				break
	temp = y
	flag = True
	while n > 0:
		if flag:
			print(temp, end=' ')
			temp = temp - gap
			n -= 1
		if temp < 1:
			flag = False
			temp = y + gap
		elif temp > 1 and flag == False:
			print(temp, end=' ')
			temp = temp + gap
			n -= 1
	print()


t_count = int(input().strip())
while t_count > 0:
	(n, x, y) = list(map(int, input().strip().split(' ')))
	diff = 1
	for i in range(n - 1, 0, -1):
		temp = (y - x) / i
		if temp == int(temp):
			diff = int(temp)
			break
	count = 0
	for i in range(x, y + 1, diff):
		print(i, end=' ')
		count += 1
	while x - diff > 0 and count < n:
		print(x - diff, end=' ')
		x -= diff
		count += 1
	while count < n:
		print(y + diff, end=' ')
		y += diff
		count += 1
	print('')
	t_count -= 1


t = int(input())
while t > 0:
	(n, x, y) = map(int, input().split())
	temp1 = n - 1
	temp = y - x
	d = y - x
	while temp1 > 0:
		if temp // temp1 == temp / temp1:
			d = temp // temp1
			break
		temp1 -= 1
	for i in range(x, y + 1, d):
		print(i, end=' ')
		n -= 1
	while n > 0:
		if x - d > 0:
			print(x - d, end=' ')
			x -= d
			n -= 1
		else:
			print(y + d, end=' ')
			y += d
			n -= 1
	print()
	t -= 1


import sys, math, heapq, copy
from collections import defaultdict, deque
from bisect import bisect_left, bisect_right
from functools import cmp_to_key
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	d = y - x
	res = d
	cnt = 2
	for i in range(1, d):
		if d % i == 0:
			count = d // i + 1
			if count <= n:
				res = i
				cnt = count
				break
	z = n - cnt
	if x % res == 0:
		prev = x // res - 1
	else:
		prev = x // res
	x -= min(prev, z) * res
	z -= min(prev, z)
	y += z * res
	for i in range(x, y + 1, res):
		print(i, end=' ')
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = [float('inf'), float('inf'), float('inf')]
	for s in range(1, 51):
		for d in range(1, 51):
			l = [s + i * d for i in range(n)]
			if x in l and y in l:
				if ans[0] > l[-1]:
					ans[0] = l[-1]
					ans[1] = s
					ans[2] = d
	s = ans[1]
	d = ans[2]
	res = [s + i * d for i in range(n)]
	print(*res)


import sys
input = sys.stdin.readline
from collections import defaultdict
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
		continue
	i = 1
	while True:
		l = list(range(x, y + 1, i))
		if len(l) > n or y not in l:
			i += 1
		else:
			z = x - i
			while z > 0 and len(l) < n:
				l.append(z)
				z -= i
			z = y + i
			while len(l) < n:
				l.append(z)
				z += i
			break
	print(*list(sorted(l)))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		diff = y - x
		factor = 1
		for i in range(n - 1, 0, -1):
			if diff % i == 0:
				factor = i
				break
		d = diff // factor
		rem_ele = n - factor - 1
		list_ele = [i for i in range(x, y + 1, d)]
		curr = x - d
		while curr > 0 and rem_ele:
			list_ele.append(curr)
			curr -= d
			rem_ele -= 1
		curr = y + d
		while rem_ele:
			list_ele.append(curr)
			curr += d
			rem_ele -= 1
		for i in range(n):
			print(list_ele[i], end=' ')
		print()


from math import *
t = int(input())
while t:
	t -= 1
	best = [99999999999]
	(n, x, y) = [int(x) for x in input().split()]
	for f in range(1, x + 1):
		for diff in range(1, abs(y - x + 1)):
			arr = [f]
			for i in range(n - 1):
				arr.append(arr[-1] + diff)
			if x in arr and y in arr and (best[-1] > arr[-1]):
				best = arr
	print(*best)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	r = n - 1
	while r > 0:
		if r == 1:
			s = y - x
			break
		elif (y - x) % r == 0:
			s = (y - x) // r
			break
		else:
			r = r - 1
	mi = x
	ma = y
	l = []
	for i in range((y - x) // s + 1):
		l.append(x + i * s)
	n = n - len(l)
	while mi >= 0 and n > 0:
		mi = mi - s
		if mi > 0:
			l.append(mi)
			n = n - 1
		else:
			break
	while mi <= 0 and n > 0:
		ma = ma + s
		l.append(ma)
		n = n - 1
	l.sort()
	print(*l)


from typing import List

def findFactors(num: int) -> List[int]:
	factors = []
	for i in range(1, int(num ** 0.5) + 1):
		if num % i == 0:
			factors.append(i)
			if num % (num // i) == 0 and i != num // i:
				factors.append(num // i)
	return factors

def yetAnotherArrayRestoration(n: int, x: int, y: int) -> None:
	factors = findFactors(y - x)
	factors.sort()
	smallest_diff = y - x
	for i in range(len(factors) - 1, -1, -1):
		if factors[i] * (n - 1) >= y - x:
			smallest_diff = factors[i]
	arr = []
	while x - smallest_diff > 0:
		x -= smallest_diff
	for i in range(x, y + 1, smallest_diff):
		arr.append(i)
	while len(arr) < n:
		arr.append(arr[-1] + smallest_diff)
	arr = arr[len(arr) - n:]
	for val in arr:
		print(val, end=' ')
	print()
	return
test_cases = int(input())
for _ in range(test_cases):
	inputs = list(map(int, input().split(' ')))
	yetAnotherArrayRestoration(inputs[0], inputs[1], inputs[2])


import math
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	if x < y:
		(x, y) = (y, x)
	d = x - y
	rd = 0
	for i in range(n - 1, 0, -1):
		if d % i == 0:
			rd = d // i
			break
	ty = y
	while y <= x:
		print(y, end=' ')
		y += rd
		n -= 1
	while ty - rd >= 1 and n >= 1:
		print(ty - rd, end=' ')
		ty -= rd
		n -= 1
	while n >= 1:
		print(y, end=' ')
		y += rd
		n -= 1
	print('')


def get_result():
	(n, x, y) = list(map(int, input().split()))
	if n == 2:
		return [x, y]
	diff = y - x
	min_d = diff
	for i in range(1, diff):
		if diff % i == 0 and diff // i <= n and (y - (n - 1) * i <= x):
			min_d = i
			break
	arr = []
	c = y
	while n > 0 and c > 0:
		arr.append(c)
		n -= 1
		c -= min_d
	c = y + min_d
	while n > 0:
		arr.append(c)
		n -= 1
		c += min_d
	return arr

def main():
	t = int(input())
	for i in range(t):
		for j in get_result():
			print(j, end=' ')
		print()
main()


T = int(input())
for t in range(T):
	(n, x, y) = map(int, input().split())
	mma = 10000000
	cand = 0
	for j in range(1, 100):
		if (y - x) % j == 0 and (y - x) // j < n:
			if max((y - x) % j + (n - 1) * j, y) < mma:
				mma = max((y - x) % j + (n - 1) * j, y)
				h = max(x % j, y - (n - 1) * j)
				if h == 0:
					h = j
				cand = [str(h + j * k) for k in range(n)]
	print(' '.join(cand))


from math import ceil

def main():
	t = int(input())
	for _ in range(t):
		(n, x, y) = [int(x) for x in input().split()]
		d = ceil((y - x) / (n - 1))
		diff = y - x
		while diff % d != 0:
			d += 1
		already = diff / d + 1
		n -= already
		ans = []
		ans.append(x)
		ans.append(y)
		i = x + d
		while i < y:
			ans.append(i)
			i += d
		i = x - d
		while i > 0 and n > 0:
			ans.append(i)
			i -= d
			n -= 1
		i = y + d
		while n > 0:
			ans.append(i)
			i += d
			n -= 1
		print(*ans, sep=' ')
main()


tt = int(input())
import copy
import math
while tt > 0:
	tt -= 1
	(n, x, y) = map(int, input().split())
	if (y - x) % (n - 1) == 0:
		d = (y - x) // (n - 1)
		for i in range(n):
			print(x + i * d, end=' ')
		print()
	else:
		j = n - 1
		while (y - x) % (j - 1) != 0:
			j -= 1
		d = (y - x) // (j - 1)
		t = copy.deepcopy(x) - d
		c = j
		for i in range(j):
			print(x + i * d, end=' ')
		while t > 0 and c < n:
			print(t, end=' ')
			t -= d
			c += 1
		if c < n:
			for i in range(1, n - c + 1):
				print(y + d * i, end=' ')
		print()


def findMinimumStart(increment, x, y, ran):
	minimum = y - ran
	while minimum < 1:
		minimum = minimum + increment
	return minimum
t = int(input())
result = []
for i in range(t):
	(n, x, y) = [int(x) for x in input().split(' ')]
	out = []
	if n == 2:
		out = [x, y]
		result.append(out)
		continue
	dif = y - x
	for increment in range(1, dif + 1):
		if dif % increment == 0:
			ran = increment * (n - 1)
			if ran < dif:
				continue
			else:
				break
	minimum = findMinimumStart(increment, x, y, ran)
	out.append(minimum)
	for j in range(n - 1):
		out.append(out[-1] + increment)
	result.append(out)
for x in result:
	print(*x)


def main():
	T = eval(input())
	for cas in range(T):
		(n, x, y) = map(int, input().split())
		cnt = 1
		while True:
			if (y - x) % cnt == 0 and (y - x) // cnt <= n - 1:
				counter = 0
				tmp = x
				while tmp <= y:
					print('{} '.format(tmp), end='')
					tmp += cnt
					counter += 1
				tmp = x - cnt
				while counter < n and tmp > 0:
					print('{} '.format(tmp), end='')
					counter += 1
					tmp -= cnt
				tmp = y + cnt
				while counter < n:
					print('{} '.format(tmp), end='')
					counter += 1
					tmp += cnt
				break
			cnt += 1
		print()
main()


T = int(input())
while T > 0:
	(n, x, y) = map(int, input().split())
	diff = -1
	for i in range(1, y - x + 1):
		if (y - x) % i == 0:
			times = (y - x) // i + 1
			if times <= n:
				diff = i
				break
	res = []
	for i in range(x, y + 1, diff):
		res.append(i)
	if len(res) < n:
		start = x - diff
		while start > 0:
			res.append(start)
			if len(res) == n:
				break
			start -= diff
	if len(res) < n:
		start = y + diff
		while len(res) < n:
			res.append(start)
			start += diff
	print(*res)
	T -= 1


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = y - x
	ans = -1
	if n == 2:
		print(x, y)
		continue
	for i in range(1, d):
		if (d - i) % i == 0 and (d - i) // i <= n - 2:
			ans = i
			break
	if ans == -1:
		h = 2
		f = x - d
		print(x, y, end=' ')
		while f > 0 and h < n:
			print(f, end=' ')
			f -= d
			h += 1
		f = y + d
		while h < n:
			print(f, end=' ')
			f += d
			h += 1
		print()
		continue
	f = x - ans
	gr = 2
	print(x, y, end=' ')
	while gr < n:
		if x + ans == y:
			break
		print(x + ans, end=' ')
		x += ans
		gr += 1
	while f > 0 and gr < n:
		print(f, end=' ')
		f -= ans
		gr += 1
	while gr < n:
		print(y + ans, end=' ')
		y += ans
		gr += 1
	print()


from sys import stdin, stdout

def input():
	a = stdin.readline()
	if a[-1] == '\n':
		a = a[:-1]
	return a

def print(*argv, end='\n', sep=' '):
	n = len(argv)
	for i in range(n):
		if i == n - 1:
			stdout.write(str(argv[i]))
		else:
			stdout.write(str(argv[i]) + sep)
	stdout.write(end)
mod = 10 ** 9 + 7

def lcm(x, y):
	from math import gcd
	return x * y / gcd(x, y)

def comb(lst, x):
	from itertools import combination as c
	return list(comb(lst, x))

def fact(x, mod=mod):
	ans = 1
	for i in range(1, x + 1):
		ans = ans * i % mod
	return ans

def arr2D(n, m, default=0):
	lst = []
	for i in range(n):
		temp = [default] * m
		lst.append(temp)
	return lst

def sortDictV(x):
	return {k: v for (k, v) in sorted(x.items(), key=lambda item: item[1])}

def solve(n, x, y):
	var = -1
	for i in range(1, y - x):
		if (y - x) % i == 0:
			val = y - (n - 1) * i
			if val <= x:
				var = i
				break
	if var == -1:
		var = y - x
	lst = [x]
	x1 = x
	for i in range(n - 1):
		if x1 < y:
			x1 += var
			lst.append(x1)
		elif x - var > 0:
			x -= var
			lst.append(x)
		else:
			x1 += var
			lst.append(x1)
	return lst
for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	print(' '.join(list(map(str, solve(n, x, y)))))


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ind = float('inf')
	key = float('inf')
	for i in range(1, y - x + 1):
		nco = n - 2
		if (y - x) % i == 0:
			nco -= (y - x) // i - 1
			if nco >= 0:
				nco -= min(nco, (x - 1) // i)
				nex = y + nco * i
				if nex < key:
					key = nex
					ind = i
	front = [y]
	su = y
	nco = n - 1
	while su != key:
		su += ind
		front.append(su)
		nco -= 1
	back = []
	su = y
	while nco:
		su -= ind
		back.append(su)
		nco -= 1
	print(*back[::-1] + front)


def divisors(a: int) -> list:
	out = []
	for i in range(1, a + 1):
		if a % i == 0:
			out.append(i)
	return out
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	div = divisors(y - x)
	ans = []
	for d in div:
		if n * d < y - x:
			continue
		r = y % d
		top = max(y, (n - (1 if r > 0 else 0)) * d + r)
		low = top - (n - 1) * d
		if low <= x and low > 0:
			ans.append((low, top, d))
	(low, top, d) = min(ans, key=lambda x: x[1])
	arr = [a for a in range(low, top + 1, d)]
	print(*arr)


from math import *
t = int(input())
while t:
	t -= 1
	(n, x, y) = map(int, input().split())
	l = []
	if y < x:
		(x, y) = (y, x)
	if n - 1 >= y - x:
		step = 1
		for i in range(y, 0, -1):
			if len(l) < n:
				l.append(i)
			else:
				break
		i = y + step
		while len(l) < n:
			l.append(i)
			i += step
	else:
		temp = y - x
		for i in range(ceil((y - x) / (n - 1)), y - x + 1):
			if temp % i == 0:
				step = i
				break
		for i in range(y, 0, -step):
			if len(l) < n:
				l.append(i)
			else:
				break
		i = y + step
		while len(l) < n:
			l.append(i)
			i += step
	l.sort()
	for i in l:
		print(i, end=' ')
	print()


from functools import lru_cache
from sys import stdin, stdout
import sys
from math import *
for __ in range(int(input())):
	(n, x, y) = map(int, input().split())
	temp = -1
	for i in range(1, n):
		if (y - x) % i == 0:
			temp = (y - x) // i
	ans = []
	s = y
	while len(ans) < n and s > 0:
		ans.append(s)
		s -= temp
	s = y + temp
	while len(ans) < n:
		ans.append(s)
		s += temp
	print(*ans)


def algo(n, x, y):
	d = y - x
	for j in range(n, 1, -1):
		i = j - 1
		while i > 0:
			m = j - i
			rem = d % m
			if not rem:
				dd = d // m
				a1 = y - dd * (j - 1)
				if a1 > 0:
					return ' '.join([str(a1 + k * dd) for k in range(n)])
			i -= 1
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = algo(n, x, y)
	print(ans)


T = int(input())
for t in range(T):
	(n, x, y) = map(int, input().split())
	diff = y - x
	flg1 = False
	if n == 2:
		print(min(x, y), max(x, y))
	else:
		for b in range(n, 0, -1):
			for a in range(1, b):
				for d in range(diff, 0, -1):
					if (b - a) * d == diff:
						(ans_a, ans_b, ans_d) = (a, b, d)
						flg1 = True
						break
				if flg1:
					break
			if flg1:
				break
		first = x - (ans_a - 1) * ans_d
		if first < 0:
			first = first % ans_d
		if first == 0:
			first += ans_d
		for i in range(n):
			print(first + i * ans_d, end=' ')
		print()


def func(n, a, b):
	res = []
	gap = b - a
	for i in range(n - 1, 0, -1):
		if gap % i == 0:
			break
	if i != 0:
		i = gap // i
		j = a
		while n > 0 and j <= b:
			res.append(j)
			j += i
			n -= 1
		j = a - i
		while n > 0 and j > 0:
			res.append(j)
			j -= i
			n -= 1
		j = b + i
		while n > 0:
			res.append(j)
			j += i
			n -= 1
	return res
t = int(input())
for i in range(t):
	(n, a, b) = list(map(int, input().split()))
	res = func(n, a, b)
	for i in res:
		print(i, end=' ')
	print()


t = int(input())
for i in range(t):
	l = list(map(int, input().split()))
	(n, x, y) = l
	l1 = []
	c = x
	fl = 0
	for j in range(n - 1, 0, -1):
		if (y - x) % j == 0 and fl == 0:
			while c <= y:
				l1.append(c)
				c = c + (y - x) / j
			if x - (n - (j + 1)) * ((y - x) / j) >= 1:
				c1 = x - (y - x) / j
				for h in range(n - (j + 1)):
					l1.append(c1)
					c1 = c1 - (y - x) / j
			else:
				c2 = x - (y - x) / j
				f = 0
				co = n - (j + 1)
				while co > 0:
					if c2 >= 1 and f == 0:
						l1.append(c2)
						c2 = c2 - (y - x) / j
					elif f == 0:
						l1.append(y + (y - x) / j)
						f = 1
						c2 = y + 2 * ((y - x) / j)
					else:
						l1.append(c2)
						c2 = c2 + (y - x) / j
					co = co - 1
			fl = 1
	for g in range(n):
		print(int(l1[g]), end=' ')
	print()


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	d = y - x
	for j in range(1, n):
		if d % (n - j) == 0:
			f = n - j
			break
	d = d // f
	for k in range(f + 1):
		print(x + d * k, end=' ')
	n = n - f - 1
	k = 1
	while n > 0:
		s = x - k * d
		if s > 0:
			print(s, end=' ')
			n = n - 1
			k = k + 1
		else:
			k = 1
			break
	while n > 0:
		print(y + d * k, end=' ')
		n = n - 1
		k = k + 1
	print('')


for t in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	b = y - x
	a = []
	a.append(x)
	a.append(y)
	count = 0
	for element in range(n - 1, 0, -1):
		if b % element == 0:
			c = int(b / element)
			for item in list(range(1, n - 1 - count)):
				a.append(a[0] + c * item)
			break
		count += 1
	if count == 0:
		print(' '.join((str(elem) for elem in a)))
	else:
		a.sort()
		for item in list(range(1, count + 1)):
			if min(a) - c >= 1:
				a.append(min(a) - c)
			else:
				a.append(max(a) + c)
		print(' '.join((str(elem) for elem in a)))


from sys import stdin, stdout
import heapq
import cProfile
from collections import Counter, defaultdict, deque
from functools import reduce
import math

def get_int():
	return int(stdin.readline().strip())

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

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

def solve():
	(n, a, b) = get_tuple()
	diff = b - a
	(final_ub, final_lb, final_gap) = (float('inf'), 1, 1)
	for val in range(1, diff + 1):
		(div, mod) = divmod(diff, val)
		if mod == 0:
			numb = div + 1
			if numb <= n:
				extra_req = n - numb
				(lb, ub) = (a, b)
				while extra_req > 0 and lb > 0:
					if lb - val > 0:
						extra_req -= 1
						lb -= val
					else:
						break
				while extra_req > 0:
					ub += val
					extra_req -= 1
				if ub < final_ub:
					final_ub = ub
					final_lb = lb
					final_gap = val
	ans = [final_gap * i + final_lb for i in range(n)]
	print(*ans)

def main():
	solve()
TestCases = True
if TestCases:
	for i in range(get_int()):
		main()
else:
	main()


import sys
from sys import stdin
import math

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

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

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

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

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

def flinput():
	return list(map(int, stdin.readline().strip().split()))
for _ in range(iinput()):
	(n, x, y) = minput()
	diff = y - x
	mm = 10 ** 10
	ll = []
	for i in range(diff, 0, -1):
		if diff % i == 0:
			c = 2
			list1 = [x, y]
			xx = x
			xxx = x
			yy = y
			while c != n:
				if xx + i < y:
					list1.append(xx + i)
					c += 1
					xx = xx + i
				elif xxx - i > 0:
					list1.append(xxx - i)
					c += 1
					xxx = xxx - i
				else:
					c += 1
					list1.append(yy + i)
					yy = yy + i
			list1.sort()
			dd = list1[1] - list1[0]
			ff = 0
			for i in range(2, n):
				if list1[i] - list1[i - 1] != dd:
					ff = 1
					break
			if ff == 0:
				m = max(list1)
				if m < mm:
					mm = m
					ll = list1.copy()
	print(*ll)


def task_C():
	t = int(input())
	for _ in range(t):
		(n, x, y) = map(int, input().split())
		if n == 2:
			print(x, y)
		else:
			diff = y - x
			div = n - 1
			while diff % div != 0:
				div -= 1
			step = diff // div
			count_print = 0
			flag = True
			curr_print = y
			while count_print != n:
				print(curr_print, end=' ')
				count_print += 1
				if flag:
					curr_print -= step
					if curr_print < 1:
						curr_print = y + step
						flag = False
				else:
					curr_print += step
			print()

def main():
	task_C()
main()


for _ in range(int(input())):
	inp = [int(i) for i in input().split(' ')]
	n = inp[0]
	x = inp[1]
	y = inp[2]
	rast = y - x
	m = 9999999999
	safeShag = -1
	n -= 1
	for shag in range(1, 51):
		if rast % shag != 0:
			continue
		if rast // shag > n:
			continue
		minv = y - shag * n
		while minv <= 0:
			minv += shag
			y += shag
		m = min(y, m)
		if m == y:
			safeShag = shag
	for i in range(-1, n):
		print(m, end=' ')
		m -= safeShag
	print()


import random

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

def lcm(a, b):
	return a * b / gcd(a, b)
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = -1
	for i in range(1, y - x + 1):
		if (y - x) % i == 0:
			if (y - x) // i + 1 <= n:
				diff = i
				break
	a = []
	t = x + diff
	while 1:
		t -= diff
		if t >= 1:
			a.append(t)
		else:
			break
	k = x
	while 1:
		k += diff
		if k == y:
			a.append(k)
			break
		else:
			a.append(k)
	ans = []
	if len(a) >= n:
		a.sort()
		for i in range(n):
			ans.append(a[len(a) - i - 1])
	else:
		while len(a) != n:
			k += diff
			a.append(k)
		for i in range(n):
			ans.append(a[len(a) - i - 1])
	for i in ans:
		print(i, end=' ')
	print('')


import sys, math
mod = 10 ** 9 + 7
INF = float('inf')

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

def inpl():
	return list(map(int, sys.stdin.readline().split()))
for _ in range(inp()):
	(n, x, y) = inpl()
	sa = y - x
	mx = INF
	(A, T) = (0, 0)
	for i in range(n - 1):
		for j in range(i + 1, n):
			if sa % (j - i):
				continue
			t = sa // (j - i)
			a = x - t * i
			if a <= 0:
				continue
			now = a + t * (n - 1)
			if now < mx:
				mx = now
				(A, T) = (a, t)
	res = []
	for i in range(n):
		res.append(A + T * i)
	print(*res)


t = int(input())
w = []

def func(t, h):
	i = 1
	boo = True
	while boo:
		if t % i == 0:
			if t < i * h:
				boo = False
				return i
			else:
				i = i + 1
		else:
			i = i + 1
for i in range(t):
	(n, x, y) = input().split()
	n = int(n)
	x = int(x)
	y = int(y)
	r = []
	d = func(y - x, n)
	if y >= n * d:
		for z in range(y - n * d + d, y + 1, d):
			r.append(z)
	else:
		i = 0
		c = 0
		while y - i * d > 0:
			r.append(y - i * d)
			c = c + 1
			i = i + 1
		i = 1
		while c != n:
			r.append(y + i * d)
			c = c + 1
			i = i + 1
	w.append(r)
for i in w:
	print(*i)


def arr_rest(n, x, y):
	if n == 2:
		l = [x, y]
		return l
	s = y - x
	for i in range(1, s + 1):
		if s % i == 0:
			t = s // i
			if t >= n:
				continue
			elif y - n * i > x:
				continue
			else:
				k = i
				break
		else:
			continue
	l = [x, y]
	n -= 2
	m = y
	o = y
	while n != 0:
		if m - i != x and m - i > 0:
			l.append(m - i)
			m -= i
			n -= 1
		elif m - i == x:
			m -= i
		elif m - i <= 0:
			l.append(o + i)
			o += i
			n -= 1
	return l
t = int(input())
for _ in range(t):
	nxy = input().split()
	n = int(nxy[0])
	x = int(nxy[1])
	y = int(nxy[2])
	result = arr_rest(n, x, y)
	print(*result, sep=' ')


t = int(input())
for _ in range(t):
	(n, x, y) = [*map(int, input().split())][:3]
	diff = y - x
	ans = None
	for d in range(1, diff + 1):
		if diff % d or diff // d > n - 1:
			continue
		k = min((y - 1) // d, n - 1)
		minVal = y - d * k
		maxVal = minVal + d * (n - 1)
		if ans is None or ans > maxVal:
			dans = d
			minAns = minVal
			ans = maxVal
	print(' '.join(map(str, [minAns + dans * k for k in range(0, n)])))


import sys
t = int(sys.stdin.readline())
for _ in range(t):
	(n, x, y) = map(int, sys.stdin.readline().split())
	maxs = sys.maxsize
	d = 0
	for i in range(1, n):
		if i > y - x:
			break
		if (y - x) % i == 0:
			d = (y - x) // i
			if x - d * (n - i - 1) > 0:
				maxs = y
				break
			for j in range(1, n - i):
				if x - d * (n - i - j - 1) > 0:
					maxs = y + d * j
					break
			maxs = min(maxs, y + d * (n - 2))
	print(*reversed([maxs - d * j for j in range(n)]))


import sys
import math

def answer(n, x, y):
	if n == 2:
		return [x, y]
	d = y - x
	numr = n - 2
	dary = []
	for i in range(1, int(math.sqrt(d)) + 1):
		if d % i == 0:
			dary.append(i)
			dary.append(d // i)
	dary.sort()
	for e in dary:
		if e <= numr + 1:
			best = e
		else:
			break
	lst = []
	for i in range(x, y + 1, d // best):
		lst.append(i)
	mn = x
	mx = y
	while len(lst) < n:
		if mn - d // best > 0:
			lst.append(mn - d // best)
			mn -= d // best
		else:
			lst.append(mx + d // best)
			mx += d // best
	return lst

def main():
	t = int(input())
	while t:
		(n, x, y) = [int(i) for i in sys.stdin.readline().split()]
		print(' '.join(map(str, answer(n, x, y))))
		t -= 1
	return
main()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = 0
	n1 = n
	arr = []
	if n > y - x:
		if n <= y:
			for i in range(y - n + 1, y + 1):
				arr.append(i)
		else:
			for i in range(1, n + 1):
				arr.append(i)
	else:
		temp = y - x
		for i in range(2, y - x + 1):
			if (y - x) % i == 0:
				if x + (n - 1) * i >= y:
					diff = i
					break
		val = 1 + (y - x) // diff
		val1 = (x - 1) // diff
		counter = 0
		if n > val:
			if val1 > n - val:
				counter = 1
				for i in range(1, n - val + 1):
					arr.append(x - i * diff)
			else:
				for i in range(1, val1 + 1):
					arr.append(x - i * diff)
				n = n - val1
		if counter == 0:
			for i in range(1, n - val + 1):
				arr.append(y + i * diff)
		for i in range(1, val + 1):
			arr.append(x + (i - 1) * diff)
	for i in range(n1):
		print(arr[i], end=' ')
	print()


import sys

class CYetAnotherArrayRestoration:

	def solve(self, tc=0):
		for _ in range(int(input())):
			(n, x, y) = [int(_) for _ in input().split()]
			p = 1
			for p in range(min(n - 1, y - x), 0, -1):
				if (y - x) % p == 0:
					break
			k = (y - x) // p
			a = [x + u * k for u in range(p + 1)]
			nb = len(a)
			(mn, mx) = (a[0], a[-1])
			while nb < n:
				if mn - k > 0:
					mn -= k
					a.append(mn)
				else:
					mx += k
					a.append(mx)
				nb += 1
			print(*a)
solver = CYetAnotherArrayRestoration()
input = sys.stdin.readline
solver.solve()


t = int(input())
for i in range(t):
	(n, x, y) = input().split()
	(n, x, y) = (int(n), int(x), int(y))
	l = [x, y]
	for j in range(n - 1, 0, -1):
		if (x - y) % j == 0:
			break
	a = abs(x - y) // j
	for k in range(1, j):
		l.append(min(x, y) + a * k)
	if len(l) < n:
		c = 0
		for s in range(1, n - len(l) + 1):
			b = min(x, y) - a * s
			if b > 0:
				l.append(b)
				c += 1
			else:
				l.append(max(x, y) + a * (s - c))
	print(*l)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	array = [y]
	ycopy = y
	remains = n - 1
	result = []
	for i in range(remains, 0, -1):
		check = diff / i
		if check.is_integer():
			diff = int(check)
			remains = i
			break
	previous_of = y
	neg = False
	choo = 10000000000000000000
	for i in range(n - 1):
		if choo <= diff:
			neg = True
		if not neg:
			choo = y - diff
		else:
			y = ycopy
			choo = y + diff
			ycopy = choo
		array.append(choo)
		y = choo
	print(' '.join(map(str, array)))


from math import gcd

def find_step(a, b, n):
	for step in range(1, b - a + 1):
		if (b - a) % step == 0 and (b - a) // step + 1 <= n:
			return step
	return None

def gen_ans(x, y, n, step):
	mid_len = (y - x) // step + 1
	mid = [x + i * step for i in range(mid_len)]
	l_pl_r_len = max(0, n - mid_len)
	if l_pl_r_len == 0:
		return mid
	l_len = max(0, min(x // step - (1 if x % step == 0 else 0), l_pl_r_len))
	l = [x - i * step for i in range(1, l_len + 1)]
	r_len = l_pl_r_len - l_len
	r = [y + i * step for i in range(1, r_len + 1)]
	ans = l + mid + r
	assert len(ans) == n
	assert min(ans) >= 1
	return ans

def solve(n, x, y):
	if n == 2:
		return [x, y]
	if y - x + 1 == n:
		return gen_ans(x, y, n=n, step=1)
	step = find_step(x, y, n)
	if step is not None:
		return gen_ans(x, y, n=n, step=step)
	step = gcd(y, x)
	if (y - x) // step + 1 <= n:
		return gen_ans(x, y, n=n, step=step)
	return gen_ans(x, y, n=n, step=y - x)
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	print(*solve(n, x, y))


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	div = [1]
	delta = abs(x - y)
	for d in range(2, int(abs(x - y) ** 0.5) + 1):
		if delta % d == 0:
			div.append(d)
			div.append(delta // d)
	div.append(delta)
	div.sort()
	base = 1
	step = delta
	for d in div:
		if d < n:
			base = d
			step = delta // base
	need = n
	array = []
	for i in range(n):
		if y - step * i > 0:
			array.append(y - step * i)
			need -= 1
	for i in range(need):
		array.append(y + (i + 1) * step)
	print(*array)


from sys import stdin
for _ in range(int(input())):
	(n, x, y) = map(int, stdin.readline().rstrip().split(' '))
	if n == 2:
		print(x, y)
	else:
		c = n - 1
		d = y - x
		r = 1
		for i in range(c, 1, -1):
			if d % i == 0:
				r = i
				break
		diff = d // r
		z = [y]
		start = y
		while len(z) != n:
			start = start - diff
			if start <= 0:
				break
			z.append(start)
		if len(z) < n:
			for i in range(n - len(z)):
				z.append(z[0] + diff * (i + 1))
		print(*z)


import math

def solve():
	(n, x, y) = map(int, input().split())
	p = n - 1
	k = y - x
	while True:
		if k % p == 0:
			break
		p = p - 1
	p = k // p
	c = []
	if int(math.ceil(y / p)) >= n:
		z = y - (n - 1) * p
		for i in range(0, n):
			c.append(z + i * p)
	else:
		if y % p != 0:
			z = y - y // p * p
		else:
			z = p
		for i in range(0, n):
			c.append(z + i * p)
	return c
for test in range(int(input())):
	t = solve()
	print(*t)


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
from collections import Counter, defaultdict, deque

def int1():
	return int(input())

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

def list1():
	return list(map(int, input().split()))
mod = pow(10, 9) + 7

def solve():
	(n, a, b) = map1()
	if n == 2:
		print(a, b)
	else:
		for i in range(1, 51):
			l1 = [b]
			v = b
			flag = 0
			for j in range(n - 1):
				if v <= i:
					v = b
					flag = 1
				if flag == 1:
					v = v + i
					l1.append(v)
				else:
					v = v - i
					l1.append(v)
			x = l1.count(a)
			if x != 0:
				print(*l1)
				return
for _ in range(int(input())):
	solve()


MOD = 1000000007
from collections import defaultdict as dd, Counter, deque

def si():
	return input()

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

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

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

def out(v):
	print(v)

def spout():
	print(v, end=' ')

def d2b(n):
	return bin(n).replace('0b', '')

def twod(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def vow():
	return ['a', 'e', 'i', 'o', 'u']

def let():
	return [chr(i) for i in range(97, 123)]

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

def ispow2(x):
	return x and (not x & x - 1)

def prime_factors(n):
	i = 2
	factors = []
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.append(i)
	if n > 1:
		factors.append(n)
	return list(factors)
t = ii()
while t:
	t -= 1
	(n, x, y) = mi()
	m = n
	k = 1
	f = 0
	while m > k:
		k = 1
		while k < m:
			if ((y - x) / (m - k)).is_integer():
				d = (y - x) // (m - k)
				if y - (m - 1) * d > 0:
					a = y - (m - 1) * d
					f = 1
					break
			k += 1
		if f == 1:
			break
		m -= 1
		k = 1
	for i in range(n):
		print(a, end=' ')
		a += d
	print('')


test = int(input())
for i in range(test):
	(n, a, b) = [int(x) for x in input().split(' ')]
	j = 1
	ans = -1
	flag = 0
	anss = [0] * n
	temp = []
	while j <= b:
		if (b - a) % j == 0:
			for i in range(1, a + 1):
				for k in range(n):
					if i + k * j == a:
						for l in range(k + 1, n):
							if i + l * j == b:
								temp.append([j, i])
								flag = 1
								break
						if flag == 1:
							break
					if flag == 1:
						break
			if flag == 1:
				break
		if flag == 1:
			break
		j += 1
	temp.sort()
	ans = temp[0][1]
	for i in range(n):
		anss[i] = ans + i * j
	print(*anss)


def sp(x, y, n, p):
	for q in range(1, x + 1):
		if (x - q) % p == 0 and (y - q) % p == 0:
			if p * (n - 1) + q >= y:
				return q
	return None
for t in range(int(input())):
	(n, x, y) = map(int, input().split())
	for p in range(1, y + 1 - x):
		if (y - x) % p == 0:
			q = sp(x, y, n, p)
			if q != None:
				break
	print(*range(q, p * (n - 1) + q + 1, p))


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	a = 1
	b = 1
	m = 10000000000
	for i in range(1, x + 1):
		for j in range(1, y - x + 1):
			if (x - i) % j == 0 and (y - i) % j == 0 and ((y - i) / j < n):
				s = i + (n - 1) * j
				if s < m:
					m = s
					a = i
					b = j
	l = []
	for i in range(n):
		l.append(a + b * i)
	print(*l)


def solve():
	(n, x, y) = list(map(int, input().split()))
	res = 1
	max = int(4294967295)
	for i in range(1, y - x + 1):
		if (y - x) % i != 0 or y - (n - 1) * i > x:
			continue
		_xy = (y - x) // i + 1
		_x = (x - 1) // i
		tmp = y if _xy + _x > n else y + i * (n - _xy - _x)
		if tmp < max:
			res = i
			max = tmp
	for i in range(n):
		print(max, end=' ')
		max -= res
	print()
ct = int(input())
while ct > 0:
	solve()
	ct -= 1


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	xy_diff = n - 1
	while xy_diff > 0:
		if (y - x) % xy_diff == 0:
			d = (y - x) // xy_diff
			break
		else:
			xy_diff -= 1
	ans = list()
	temp = y
	while n > 0 and temp >= 1:
		ans.append(temp)
		n -= 1
		temp -= d
	temp = y + d
	while n > 0:
		ans.append(temp)
		temp += d
		n -= 1
	print(*ans)


def Solve(n, x, y):
	if n == 2:
		print(x, y)
		return
	if y <= n:
		s = ''
		for i in range(1, n + 1):
			s += str(i) + ' '
		print(s)
	else:
		k = y - x
		for i in range(1, 50):
			if k % i == 0 and k // i <= n - 1:
				break
		arr = [x]
		r = k // i - 1
		if r + 2 == n:
			for c in range(r):
				arr.append(x + (c + 1) * i)
			arr.append(y)
			l = len(arr)
			for c in range(n - l):
				arr.insert(0, x - (c + 1) * i)
		else:
			c = 1
			l = len(arr)
			while x - c * i > 0 and l < n - r - 1:
				arr.insert(0, x - c * i)
				c += 1
				l += 1
			l = len(arr)
			for c in range(n - l):
				arr.append(x + (c + 1) * i)
		s = ''
		for num in arr:
			s += str(num) + ' '
		print(s)
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	Solve(n, x, y)


def cast(cre, typ):
	return type(typ)(map(cre, typ))

def solution():
	for t in range(int(input())):
		(n, x, y) = cast(int, input().split())
		sub = y - x
		l = [x, y]
		term = 0
		for i in range(n - 1, 0, -1):
			if sub % i == 0:
				term = sub // i
				break
		cnt = -1
		while len(l) < n:
			val = l[1] + cnt * term
			if val < 1:
				cnt = 1
				continue
			elif val != l[0]:
				l.append(val)
			cnt += -1 if cnt < 0 else 1
		print(' '.join(cast(str, l)))
solution()


from sys import stdin, stdout
for _ in range(int(stdin.readline())):
	(n, a, l) = list(map(int, stdin.readline().split()))
	min_last = float('inf')
	for i in range(n):
		for j in range(i + 1, n):
			if (l - a) % (j - i) == 0:
				d = (l - a) // (j - i)
				apf = l - j * d
				if apf < 1:
					continue
				last = apf + (n - 1) * d
				if last < min_last:
					min_last = last
					aa = apf
					dd = d
	ans = []
	for i in range(n):
		ans += [aa]
		aa += dd
	print(*ans)


from math import sqrt

def factor(d):
	f = []
	for i in range(1, int(sqrt(d)) + 1):
		if d % i == 0:
			f.append(i)
			if d % (d // i) == 0:
				f.append(d // i)
			continue
	return f

def main():
	for _ in range(int(input())):
		(n, x, y) = map(int, input().split())
		d = y - x
		f = factor(d)
		for d in sorted(f):
			t = n
			k = 0
			check = False
			ans = []
			while t:
				first = y - k * d
				if first <= 0:
					break
				ans.append(first)
				if first == x:
					check = True
				t -= 1
				k += 1
			if not check:
				continue
			if t:
				k = 1
				while t:
					ans.append(y + k * d)
					t -= 1
					k += 1
			print(*ans)
			break
main()


import os, sys
from io import BytesIO, IOBase

def main():
	for _ in range(int(input())):
		(n, x, y) = map(int, input().split())
		if y <= n:
			for i in range(1, n + 1):
				print(i, end=' ')
			print('')
		elif y - x + 1 <= n:
			r = max(1, y - n + 1)
			for i in range(r, r + n):
				print(i, end=' ')
			print('')
		else:
			for xx in range(1, 51):
				if not (y - x) % xx and (y - x) // xx + 1 <= n:
					break
			for st in range(1, x + 1):
				if not (y - st) % xx and (y - st) // xx + 1 <= n:
					(i, c) = (0, st)
					while i != n:
						print(c, end=' ')
						c += xx
						i += 1
					print('')
					break
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')
main()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	for i in range(1, y - x + 1):
		if (y - x) % i == 0 and (y - x) / i + 1 <= n:
			min_div = i
			break
	exist = (y - x) / min_div + 1
	min_needed = x
	max_needed = y
	if exist + (x - 1) // min_div >= n:
		min_needed = x - (n - exist) * min_div
	else:
		min_needed = x - (x - 1) // min_div * min_div
		exist += (x - 1) // min_div
		max_needed = y + (n - exist) * min_div
	max_needed = int(max_needed)
	min_needed = int(min_needed)
	for i in range(min_needed, max_needed + 1, min_div):
		print(i, end=' ')
	print('')


import math
from collections import deque
import sys
sys.setrecursionlimit(10 ** 4)

def Divisors(n):
	l = []
	i = 2
	while i <= math.sqrt(n):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
		i = i + 1
	return l

def SieveOfEratosthenes(n):
	l = []
	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]:
			l.append(p)
	return l

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(i)
			n = n / i
	if n > 2:
		l.append(n)
	return l

def Factors(n):
	result = []
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			if i == n / i:
				result.append(i)
			else:
				result.append(i)
				result.append(n // i)
	result.append(1)
	return result

def maxSubArraySum(a):
	max_so_far = 0
	max_ending_here = 0
	size = len(a)
	for i in range(0, size):
		max_ending_here = max_ending_here + a[i]
		if max_so_far < abs(max_ending_here):
			max_so_far = max_ending_here
	return max_so_far

def longestsubarray(arr, n, k):
	current_count = 0
	max_count = 0
	for i in range(0, n, 1):
		if arr[i] % k != 0:
			current_count += 1
		else:
			current_count = 0
		max_count = max(current_count, max_count)
	return max_count

def main():
	(n, x, y) = list(map(int, input().split()))
	l = []
	d = y - x
	p = n - 1
	while d % p != 0:
		p -= 1
	d = d / p
	c = n
	x = y
	while y > 0 and c > 0:
		l.append(int(y))
		c -= 1
		y -= d
	while c > 0:
		l.append(int(x + d))
		x += d
		c -= 1
	print(*l)
t = int(input())
for i in range(0, t):
	main()


for t in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	dif = y - x
	d = 0
	a0 = 0
	for i in range(1, n):
		if dif % i == 0:
			d = dif // i
		a0 = y - d * (n - 1)
		if a0 <= 0:
			a0 = y % d
			if a0 == 0:
				a0 = d
	for i in range(n):
		print(a0 + i * d, end=' ')
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	count_otr = n - 1
	diff = y - x
	while diff % count_otr:
		count_otr -= 1
	offset = n - 1 - count_otr
	step = diff // count_otr
	offset = min(offset, (x - 1) // step)
	arr = [x - (offset - i) * step for i in range(n)]
	print(*arr)


T = int(input())
for t in range(T):
	(n, x, y) = map(int, input().split())
	ld = y - x
	lmax = n - 1
	l = lmax
	while l > 1:
		if ld % l == 0:
			break
		l -= 1
	d = ld // l
	back = min((x - 1) // d, n - (l + 1))
	a = x - back * d
	for i in range(n):
		print(a + i * d, end=' ')
	print('')


import sys
input = sys.stdin.readline
from math import gcd
from math import sqrt
t = int(input())
for tests in range(t):
	(n, x, y) = map(int, input().split())
	LIST = []
	for i in range(1, int(sqrt(y - x)) + 2):
		if (y - x) % i == 0:
			LIST.append(i)
			LIST.append((y - x) // i)
	ANS = (0, 0)
	ANSMAX = 1 << 60
	flag = 0
	for d in LIST:
		k = (y - x) // d
		if k + 1 > n:
			continue
		kou = y // d
		if y % d != 0:
			kou += 1
		if kou >= n:
			flag = 1
			ALIST = []
			for i in range(n):
				ALIST.append(y - i * d)
			print(*reversed(ALIST))
			break
		else:
			b = y % d
			if b == 0:
				b += d
			if ANSMAX > b + (d - 1) * n:
				ANSMAX = b + d * (n - 1)
				ANS = (b, d)
	if flag == 0:
		ALIST = []
		(b, d) = ANS
		for i in range(n):
			ALIST.append(b + i * d)
		print(*ALIST)


t = int(input())
for _ in range(t):
	(n, x, y) = list(map(int, input().split()))
	if x < y:
		(x, y) = (y, x)
	li = n * [0]
	temp_d = 1
	temp = int(1000000000.0) + 1
	for d in range(n - 1, 0, -1):
		if (x - y) % d == 0:
			a = (x - y) // d
			if y % a > 0:
				c = y % a
			else:
				c = y % a + a
			b = (x - c) // a
			if b >= n - 1:
				temp_d = d
				temp = x
				break
			elif temp > c + a * (n - 1):
				temp_d = d
				temp = c + a * (n - 1)
	if temp == int(1000000000.0) + 1:
		a = x - y
		if y % a > 0:
			temp = y % a + a * (n - 1)
		else:
			temp = a + y % a + a * (n - 1)
	a = (x - y) // temp_d
	li[0] = temp
	flag1 = li[0] != x
	flag2 = True
	for i in range(1, n):
		li[i] = li[i - 1] - a
	print(' '.join(map(str, li)))
	assert li[-1] > 0


T = int(input())
for I in range(0, T):
	X = list(map(int, input().split(' ')))
	D = 0
	for I in range(X[0] - 1, 0, -1):
		if (X[2] - X[1]) % I == 0:
			D = (X[2] - X[1]) // I
			break
	L = (X[1] - 1) // D
	M = X[0] - ((X[2] - X[1]) // D + 1)
	Q = min(L, M)
	A = []
	B = 1
	while B <= Q:
		A.append(str(X[1] - B * D))
		B += 1
	Q = X[0] - Q
	B = 0
	while B < Q:
		A.append(str(X[1] + B * D))
		B += 1
	print(' '.join(A))


T = int(input())
for _ in range(T):
	(n, x, y) = [int(x) for x in input().split(' ')]
	n -= 1
	n1 = min(y - x, n)
	while n1 > 0 and (y - x) % n1 != 0:
		n1 -= 1
	diff = (y - x) // n1
	n -= n1
	if n == 0:
		for i in list(range(x, y + 1, diff)):
			print(i, end=' ')
		print()
		continue
	n2 = min((x - 1) // diff, n)
	n -= n2
	if n == 0:
		for i in list(range(x - n2 * diff, y + 1, diff)):
			print(i, end=' ')
		print()
		continue
	n3 = n
	for i in list(range(x - n2 * diff, y + n3 * diff + 1, diff)):
		print(i, end=' ')
	print()


import math

def shrey():
	(n, x, y) = map(int, input().split())
	a = []
	d = y - x
	if n == 2:
		print(x, end=' ')
		print(y)
		return
	for i in range(1, y - x + 1):
		if (y - x) % i == 0 and (y - x) // i < n:
			d = i
			break
	print(x, end=' ')
	print(y, end=' ')
	c = 2
	i = x + d
	while i < y:
		c += 1
		print(i, end=' ')
		i += d
	if c < n:
		i = x - d
		while i > 0 and c < n:
			print(i, end=' ')
			i -= d
			c += 1
	if c < n:
		i = y + d
		while c < n:
			print(i, end=' ')
			i += d
			c += 1
	print()
T = input()
T = int(T)
for q in range(1, T + 1):
	shrey()


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	k = 1
	num = 0
	while k <= b - a:
		if (b - a) % k == 0 and (b - a) // k + 1 <= n:
			num = max(num, (b - a) // k + 1)
		k += 1
	diff = (b - a) // (num - 1)
	n -= num
	lk = [x for x in range(a, b + 1, diff)]
	while a > diff and n:
		a -= diff
		lk.append(a)
		n -= 1
	while n:
		b += diff
		lk.append(b)
		n -= 1
	print(*lk)


import os
import sys
from io import BytesIO, IOBase

def main():
	for _ in range(int(input())):
		(n, x, y) = map(int, input().split())
		m = float('inf')
		ans_a = 0
		ans_d = 0
		for i in range(1, n + 1):
			for j in range(1, i):
				if (y - x) % (i - j) == 0:
					d = (y - x) // (i - j)
					a = y - (i - 1) * d
					lst = a + (n - 1) * d
					if lst < m and a > 0:
						ans_a = a
						ans_d = d
						m = lst
		for i in range(1, n + 1):
			print(ans_a + (i - 1) * ans_d, end=' ')
		print()
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')
main()


for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	ans = []
	curdif = n - 1
	while (b - a) % curdif != 0:
		curdif -= 1
	d = (b - a) // curdif
	num = b
	while n > 0 and num > 0:
		n -= 1
		ans.append(num)
		num -= d
	num = b
	while n > 0:
		n -= 1
		num += d
		ans.append(num)
	ans.sort()
	mn = ''
	for i in range(len(ans)):
		mn += str(ans[i]) + ' '
	print(mn)


import math
from sys import stdout, stdin
from io import IOBase, BytesIO
from os import read, write, fstat
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 = read(self._fd, max(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, size: int=...):
		while self.newlines == 0:
			b = read(self._fd, max(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:
			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', 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()
(stdin, stdout) = (IOWrapper(stdin), IOWrapper(stdout))
input = lambda : stdin.readline().rstrip('\r\n')

def f(n, x, y):
	m = math.ceil((y - x) / (n - 1))
	d = y - x
	for i in range(m, y - x + 1):
		if (y - x) % i == 0:
			d = i
			break
	if x % d == 0:
		c = max(y - min(math.floor(y / d), n - 1) * d, d)
	else:
		c = max(y - min(math.floor(y / d), n - 1) * d, x % d)
	s = ''
	for i in range(0, n):
		s = s + str(c + d * i) + ' '
	return s
t = int(input())
a = [None] * t
for i in range(0, t):
	a[i] = [int(x) for x in input().split()]
for i in range(0, t):
	print(f(a[i][0], a[i][1], a[i][2]))


def fact(n):
	a = []
	for i in range(2, n + 1):
		if n % i == 0:
			a.append(i)
	return a
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		k = abs(x - y)
		if n - 2 >= k - 1:
			ans = []
			for i in range(max(x, y), 0, -1):
				if n == 0:
					break
				else:
					ans.append(i)
					n -= 1
			for i in range(max(x, y) + 1, 10000):
				if n == 0:
					break
				else:
					ans.append(i)
					n -= 1
			print(*ans)
		else:
			a = fact(k)
			for i in a:
				temp = k // i - 1
				if temp <= n - 2:
					break
			rm = n - 2 - temp
			ans = []
			for j in range(max(x, y), 0, -i):
				ans.append(j)
				n -= 1
				if n == 0:
					break
			for j in range(max(x, y) + i, 10000, i):
				if n == 0:
					break
				else:
					ans.append(j)
					n -= 1
			print(*ans)


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	dif = y - x
	i = n - 1
	l = []
	while i >= 1:
		if dif % i == 0:
			p = dif // i
			break
		i -= 1
	z = x
	while z <= y:
		l.append(z)
		z += p
	z = x - p
	c = len(l)
	while z >= 1 and c < n:
		l.append(z)
		z = z - p
		c += 1
	z = y + p
	while c < n:
		l.append(z)
		z += p
		c += 1
	print(*l)


from collections import *
import sys

def ri():
	return int(input())

def rl():
	return list(map(int, input().split()))
t = ri()
for _ in range(t):
	(n, x, y) = rl()
	diff = y - x
	res = y + (y - x) * n
	for idx_y in range(n, 0, -1):
		for idx_x in range(1, idx_y):
			if diff % (idx_y - idx_x) == 0:
				step = diff // (idx_y - idx_x)
				if x - (idx_x - 1) * step >= 1 and x - (idx_x - n) * step <= res:
					ans = (x - (idx_x - 1) * step, step)
					res = x - (idx_x - n) * step
	print(*[ans[0] + i * ans[1] for i in range(0, n)])


t = int(input())

def restore(n, x, y):
	if y <= n:
		return [i + 1 for i in range(n)]
	if y - x < n:
		return [y - n + i + 1 for i in range(n)]
	Found = False
	i = 2
	while not Found:
		if (y - x) % i == 0 and 1 + (y - x) // i <= n:
			Found = True
			continue
		i += 1
	k = 1
	arr = []
	while x - k * i > 0 and k + (y - x) // i < n:
		arr.append(x - k * i)
		k += 1
	arr.reverse()
	arr.append(x)
	n = n - k
	k = 1
	while k < n + 1:
		arr.append(x + k * i)
		k += 1
	return arr
for i in range(t):
	(n, x, y) = input().split()
	nums = restore(int(n), int(x), int(y))
	print(*nums)


from sys import stdin, stdout

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

def main():
	t = int(stdin.readline())
	for _ in range(t):
		(n, x, y) = [int(i) for i in stdin.readline().split()]
		diff = abs(x - y)
		f = factors(diff)
		step = f[0]
		for i in f:
			if diff // i <= n - 1:
				step = i
			else:
				break
		l = list(range(min(x, y), max(x, y) + 1, step))
		l.reverse()
		while l[-1] >= step + 1 and len(l) < n:
			l.append(l[-1] - step)
		l.reverse()
		while len(l) < n:
			l.append(l[-1] + step)
		for i in l:
			stdout.write('{} '.format(i))
		stdout.write('\n')
main()


q = int(input())
ans = []
for _ in range(q):
	(n, a, b) = map(int, input().split())
	diff = 1
	num = 1
	for i in range(n - 1, 0, -1):
		if (b - a) % i == 0:
			diff = (b - a) // i
			num = i
			break
	first = a % diff
	if first == 0:
		first = diff
	last = first + (n - 1) * diff
	if last < b:
		last = b
		first = b - (n - 1) * diff
	tmp = [x for x in range(first, last + 1, diff)]
	ans.append(tmp)
for an in ans:
	print(' '.join(map(str, an)))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	arr = [x, y]
	diff = y - x
	ans = 0
	for i in range(diff, 0, -1):
		if diff % i == 0 and diff // (diff // i) <= n - 1:
			ans = i
			break
	if ans:
		ans = diff // ans
	i = x
	while i + ans < y and ans != 0:
		arr.append(i + ans)
		i += ans
	man = x
	women = y
	p = 1
	q = 1
	for j in range(n - len(arr)):
		if man - ans * p > 0:
			arr.append(man - ans * p)
			p += 1
		else:
			arr.append(women + ans * q)
			q += 1
	for k in arr:
		print(k, end=' ')
	print()


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
		continue

	def make_divisors(n):
		(lower_divisors, upper_divisors) = ([], [])
		i = 1
		while i * i <= n:
			if n % i == 0:
				lower_divisors.append(i)
				if i != n // i:
					upper_divisors.append(n // i)
			i += 1
		return lower_divisors + upper_divisors[::-1]
	cnt = make_divisors(y - x)
	for c in cnt:
		if (y - x) // c <= n - 1:
			if ((y - x) / c).is_integer():
				break
	mod = x % c
	if mod > 0:
		ans = [c * i + mod for i in range(n)]
	else:
		ans = [c * (i + 1) + mod for i in range(n)]
	diff = y - ans[-1]
	if diff > 0:
		add = (diff + c - 1) // c * c
		ans = [x + add for x in ans]
	print(*ans)


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	ans = []
	if n == 2:
		print(x, y)
		continue
	gap = y - x
	n -= 1
	if (y - x) % n == 0:
		gap = (y - x) // n
		start = x
		while start <= y:
			ans.append(start)
			start += gap
		for num in ans:
			print(num, end=' ')
		print()
		continue
	for i in range(n - 1, 0, -1):
		if (y - x) % i == 0:
			gap = (y - x) // i
			start = x
			while start <= y:
				ans.append(start)
				start += gap
				n -= 1
			break
	while n >= 0 and x - gap > 0:
		ans.append(x - gap)
		x -= gap
		n -= 1
	while n >= 0:
		ans.append(y + gap)
		y += gap
		n -= 1
	for num in ans:
		print(num, end=' ')
	print()


from functools import lru_cache
test_cases = int(input())

@lru_cache(None)
def get_best_starting_value(n, x, y) -> [int, int]:
	for value in range(y, y * n):
		for i in range(1, x + 1):
			if (value - i) % (n - 1) == 0:
				iteration_distance = (value - i) // (n - 1)
				if iteration_distance > 0 and value - iteration_distance * (n - 1) <= x:
					if (x - i) % iteration_distance == 0 and (y - i) % iteration_distance == 0:
						return (value, iteration_distance)

@lru_cache(None)
def get_result(n, x, y) -> str:
	if n == 2:
		return f'{x} {y}'
	(best_max_value, iteration_value) = get_best_starting_value(n, x, y)
	result = []
	while len(result) != n:
		result.append(str(best_max_value))
		best_max_value -= iteration_value
	return ' '.join(result)

def handle() -> str:
	(n, x, y) = input().split(' ')
	n = int(n)
	x = int(x)
	y = int(y)
	if x > y:
		(x, y) = (y, x)
	return get_result(n, x, y)
for _ in range(test_cases):
	print(handle())


m = int(input())
for i in range(m):
	(n, x, y) = map(int, input().split())
	for j in range(1, y - x + 1, 1):
		if (y - x) % j == 0 and (y - x) // j + 1 <= n:
			lis = []
			lis += list(range(x, y + 1, j))
			k = n - len(lis)
			lis += list(range(x - j, 0, -j))[:k]
			k = n - len(lis)
			lis += list(range(y + j, y + (k + 1) * j, j))
			print(*lis)
			break


import sys
input = sys.stdin.readline
t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(*[x, y])
	else:
		a = y - x
		d = 1
		l = 1
		r = 1
		for i in range(1, n + 1):
			for j in range(i + 1, n + 1):
				p = j - i
				if a % p == 0:
					q = a // p
					if x - (i - 1) * q > 0:
						if j > r:
							r = j
							l = i
		e = r - l
		f = a // e
		t = [x, y]
		h = f
		g = f
		for i in range(l + 1, r):
			t.append(x + h)
			h += f
		for i in range(1, l):
			t.append(x - g)
			g += f
		k = f
		for i in range(r + 1, n + 1):
			t.append(y + k)
			k += f
		print(*t)


from math import gcd
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	mini = float('inf')
	mina = []
	for d in range(1, 50 + 1):
		if (x - y) % d == 0:
			ca = [x + d * i for i in range((y - x) // d + 1)]
			ca.reverse()
			for _ in range(n - len(ca)):
				if ca[-1] - d <= 0:
					break
				ca.append(ca[-1] - d)
			ca.reverse()
			for _ in range(n - len(ca)):
				ca.append(ca[-1] + d)
			ca = sorted(ca)
			if len(ca) == n and all((ca[i + 1] - ca[i] == ca[n - 1] - ca[n - 2] for i in range(n - 1))) and (x in ca) and (y in ca):
				cm = max(ca)
				if cm < mini:
					mini = cm
					mina = ca
	print(*mina)


def solution(n, x, y):
	temp = n
	while (y - x) % (temp - 1):
		temp -= 1
	gap = (y - x) // (temp - 1)
	res = [i for i in range(x, y + 1, gap)]
	if len(res) == n:
		return res
	c = n - len(res)
	while c and x - gap > 0:
		res.append(x - gap)
		x -= gap
		c -= 1
	c = n - len(res)
	while c:
		res.append(y + gap)
		y += gap
		c -= 1
	return res
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split(' '))
	print(*solution(n, x, y))


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	a_n_max = float('inf')
	d_max = 0
	for n1 in range(2, n + 1):
		d = (y - x) / (n1 - 1)
		if d % 1 == 0:
			for pos in range(n, n1 - 1, -1):
				a1 = y - d * (pos - 1)
				if a1 > 0:
					a_n = a1 + d * (n - 1)
					if a_n < a_n_max:
						a_n_max = int(a_n)
						d_max = int(d)
	arr = [0] * n
	arr[-1] = a_n_max
	for i in range(n - 2, -1, -1):
		arr[i] = arr[i + 1] - d_max
	print(' '.join((str(i) for i in arr)))


import sys
sysinput = sys.stdin.readline
import time
start_time = time.time()

def inp():
	return int(sysinput())

def inlt():
	return list(map(int, sysinput().split()))

def insr():
	s = sysinput()
	return list(s[:len(s) - 1])

def invr():
	return map(int, sysinput().split())
t = inp()
while t > 0:
	t -= 1
	(n, x, y) = inlt()
	diff = y - x
	d_min = 1
	arr = [x, y]
	for i in range(1, diff + 2):
		for j in range(0, i):
			if diff % (i - j) == 0:
				d = diff // (i - j)
				if n - x // d >= 0:
					an = x + (n - 1) * d
					if an >= y:
						d_min = d
						break
	d = d_min
	val = x
	n -= 2
	while val + d < y and n > 0:
		val += d
		arr.append(val)
		n -= 1
	mina = x
	while mina - d > 0 and n > 0:
		mina -= d
		arr.append(mina)
		n -= 1
	maxa = y
	while n > 0:
		maxa += d
		arr.append(maxa)
		n -= 1
	arr.sort()
	for i in arr:
		print(i)


def main(n, x, y):
	d = 9999999999
	idx = -1
	for i in range(1, n):
		n1 = i
		t = (y - x) / (n - n1)
		if t.is_integer():
			if t < d:
				d = t
				idx = n - n1
	res = []
	c = 0
	for i in range(idx + 1):
		p = x + i * d
		res.append(p)
		c += 1
	if n == idx + 1:
		return [int(i) for i in res]
	for i in range(1, n):
		p = x - i * d
		if p > 0:
			c += 1
			res.append(p)
		if len(res) == n:
			return [int(i) for i in res]
		if p < 0:
			continue
	if len(res) == n:
		return
	for i in range(c, n):
		p = min(res) + i * d
		res.append(p)
	return [int(i) for i in res]
k = int(input())
for i in range(k):
	(n, x, y) = map(int, input().split())
	t = main(n, x, y)
	print(*t, sep=' ')


from sys import *
t = int(stdin.readline())
for _ in range(t):
	(n, x, y) = map(int, stdin.readline().split())
	m = n
	n -= 1
	m -= 1
	a = y - x
	for i in range(n, -1, -1):
		if i == 0:
			break
		elif a % i == 0:
			break
	n = i
	m -= n
	ans = [x]
	i = x
	c = a // n
	while i < y:
		i += c
		ans.append(i)
	j = x
	ans1 = []
	while j > 0 and m > 0:
		j -= c
		if j <= 0:
			break
		m -= 1
		ans1.append(j)
	ans1 = ans1[::-1]
	k = y
	while m > 0:
		m -= 1
		k += c
		ans.append(k)
	for i in range(len(ans)):
		ans1.append(ans[i])
	print(*ans1)


import math

def find(n1, x1, y1, res, div):
	if n1 == 0:
		return True
	sub = (y1 - x1) // div - 1
	for i in range(1, sub + 1):
		res.append(x1 + div * i)
	if n1 < sub:
		return False
	elif n1 == sub:
		return True
	else:
		n1 -= sub
		sub1 = (x1 - 1) // div
		if n1 <= sub1:
			for i in range(1, n1 + 1):
				res.append(x1 - div * i)
		else:
			for i in range(1, sub1 + 1):
				res.append(x1 - div * i)
			n1 -= sub1
			for i in range(1, n1 + 1):
				res.append(y1 + div * i)
		return True
for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	fac = []
	sub = y - x
	for i in range(1, int(math.sqrt(sub)) + 1):
		if sub % i == 0:
			fac.append(i)
			fac.append(sub // i)
	fac.sort()
	for i in fac:
		res = [x, y]
		if find(n - 2, x, y, res, i):
			for j in res:
				print(j, end=' ')
			print()
			break


def check(f, n, d):
	if d // f <= n - 1:
		return True
	return False
for _ in range(int(input())):
	(n, x, y) = map(int, input().rstrip().split())
	d = y - x
	ans = [x, y]
	a = 1
	r = False
	i = 0
	while r != True:
		i += 1
		if d % i == 0:
			r = check(i, n, d)
	if d // i == n - 1:
		for k in range(n - 1):
			print(x, end=' ')
			x += i
		print(y)
	else:
		temp1 = x
		while n > 0 and temp1 < y:
			temp1 += i
			print(temp1, end=' ')
			n -= 1
		temp = x
		while temp > 0 and n > 0:
			print(temp, end=' ')
			temp -= i
			n -= 1
		while n > 0:
			y += i
			print(y, end=' ')
			n -= 1
		print()


t = int(input())
for i in range(t):
	(n, x, y) = map(int, input().split())
	diff = y - x
	segment = n - 1
	start = x
	d = diff // segment
	if diff % segment != 0:
		d += 1
		while diff % d != 0:
			d += 1
	remaining = segment - diff // d
	while remaining > 0 and start - d > 0:
		remaining -= 1
		start -= d
	for j in range(n):
		if j == 0:
			print('{}'.format(start), end='')
		else:
			print(' {}'.format(start + j * d), end='')
	print()


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	st = set()
	raj = abs(x - y)
	hr = raj
	rajx = x
	rajy = y
	f = 0
	st.add(x)
	st.add(y)
	for i in range(1, hr + 1):
		if raj % i == 0:
			if x + (n - 1) * i >= y:
				hr = i
				f = 1
				break
	wd = len(st)
	x = rajx + hr
	while x < rajy:
		st.add(x)
		x += hr
		wd = len(st)
	x = rajx - hr
	while x > 0 and wd < n:
		st.add(x)
		x -= hr
		wd = len(st)
	x = rajy + hr
	while wd < n:
		st.add(x)
		x += hr
		wd = len(st)
	for i in st:
		print(i, end=' ')
	print()


import sys
import collections as cc
import math as mt
I = lambda : list(map(int, input().split()))
for tc in range(int(input())):
	(n, x, y) = I()
	dif = -1
	for i in range(1, 50):
		nn = 0
		(xx, yy) = (x, y)
		tf = 0
		temp = [x]
		dif = i
		while nn <= n - 2:
			xx += i
			nn += 1
			temp.append(xx)
			if xx == yy:
				tf = 1
				break
		if tf:
			break
	nl = len(temp)
	if nl == n:
		print(*temp)
	else:
		front = []
		ii = temp[0] - dif
		while nl != n and ii > 0:
			front.append(ii)
			ii -= dif
			nl += 1
		back = []
		front = front[::-1]
		jj = temp[-1] + dif
		while nl != n:
			back.append(jj)
			jj += dif
			nl += 1
		anss = front + temp + back
		print(*anss)


from math import inf
for _ in range(int(input())):
	a = []
	(n, x, y) = map(int, input().split())
	z = y - x
	d = 1
	while True:
		if z % d == 0 and z // d + 1 <= n:
			break
		else:
			d += 1
	ans = z // d + 1
	(l, r) = (x, y)
	for i in range(ans):
		a.append(l + i * d)
	n -= ans
	while l > 0 and n > 0:
		l -= d
		if l > 0:
			a.append(l)
			n -= 1
	i = 1
	while n != 0:
		a.append(r + i * d)
		n -= 1
		i += 1
	print(*a)


def con(n):
	o = []
	for s in n:
		s = str(s)
		o.append(s)
	return ' '.join(o)
t = int(input())
i = 0
while i < t:
	(n, x, y) = input().split()
	n = int(n)
	x = int(x)
	y = int(y)
	cd = 0
	if (y - x) % (n - 1) == 0:
		cd = (y - x) // (n - 1)
	else:
		for s in range(n, 0, -1):
			if (y - x) % (s - 1) == 0:
				cd = (y - x) // (s - 1)
				break
	j = 0
	k = []
	a = x
	b = x - cd
	c = y + cd
	while j < n:
		if x <= a <= y:
			k.append(a)
			a += cd
		elif a == y + cd and b > 0:
			k.append(b)
			b = b - cd
		elif b <= 0:
			k.append(c)
			c += cd
		j += 1
	print(con(k))
	i += 1


(T,) = map(int, input().split())
for _ in range(T):
	(n, xx, yy) = map(int, input().split())
	RR = []
	for i in range(1, n):
		(x, y) = (xx, yy)
		R = [x, y]
		if (y - x) % i:
			continue
		tmp = (y - x) // i
		nk = n - (i + 1)
		for j in range(i - 1):
			R.append(x + (j + 1) * tmp)
		for _ in range(nk):
			if x - tmp > 0:
				x -= tmp
				R.append(x)
			else:
				y += tmp
				R.append(y)
		RR.append((R, max(R)))
	print(*sorted(RR, key=lambda x: x[1])[0][0])


def check(n, a, b):
	v = []
	for i in range(1, a + 1):
		for d in range(1, b - a + 1):
			if (b - a) % d:
				continue
			x = [x for x in range(i, d * n + i, d)]
			if b in x and a in x:
				v += [x]
	l = [max(k) for k in v]
	return v[l.index(min(l))]
for _ in range(int(input())):
	(n, a, b) = map(int, input().split())
	print(*check(n, a, b))


import sys
input = sys.stdin.readline
from bisect import bisect_left
from bisect import bisect_right
from math import ceil, factorial

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

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

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	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
	return prime
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

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

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

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
for _ in range(int(input())):
	(n, x, y) = int_array()
	ans = []
	for i in range(n - 1):
		for j in range(i + 1, n):
			d = (y - x) / (j - i)
			first = x - i * d
			if d == int(d) and first > 0:
				ans.append((i, j))
	this = -1
	ours = None
	for i in ans:
		if i[1] > this:
			this = i[1]
			ours = i
	ans = [None] * n
	(i, j) = ours
	ans[i] = x
	ans[j] = y
	d = (y - x) / (j - i)
	first = x - i * d
	for p in range(n):
		ans[p] = int(first + p * d)
	print(*ans)


for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	arr = []
	flag = True
	for i in reversed(range(1, n)):
		if (y - x) % i == 0:
			num = 1
			for j in range(n):
				temp = y - (y - x) // i * j
				if temp > 0:
					arr.append(temp)
				else:
					arr.append(y + (y - x) // i * num)
					num += 1
			flag = False
			break
	print(*arr)


from sys import stdin, stdout
from math import gcd, sqrt, factorial, pi
from collections import deque, defaultdict
input = stdin.readline
R = lambda : map(int, input().split())
I = lambda : int(input())
S = lambda : input().rstrip('\n')
L = lambda : list(R())
P = lambda x: stdout.write(x)
lcm = lambda x, y: x * y // gcd(x, y)
hg = lambda x, y: (y + x - 1) // x * x
pw = lambda x: 1 if x == 1 else 1 + pw(x // 2)
chk = lambda x: chk(x // 2) if not x % 2 else True if x == 1 else False
sm = lambda x: (x ** 2 + x) // 2
N = 10 ** 9 + 7
for _ in range(I()):
	(n, a, b) = R()
	v = b - a
	for i in range(1, v + 1):
		if v % i == 0:
			x = [b]
			for k in range(n - 1):
				x += (x[-1] - i,)
			if a in x and b in x:
				val = i
				while min(x) <= 0:
					x = [p + val for p in x]
				print(*x)
				break
			else:
				continue


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	diff = y - x
	flag = False
	for posy in range(n, 0, -1):
		for posx in range(posy - 1, 0, -1):
			dist = posy - posx
			if diff % dist > 0:
				continue
			mul = diff // dist
			if x - mul * posx + mul <= 0:
				continue
			print(' '.join([str(x - mul * posx + mul * i) for i in range(1, n + 1)]))
			flag = True
			break
		if flag:
			break


import math

def divisors(num, x, y, n):
	p = num
	for i in range(1, num + 1):
		if num % i == 0 and y - i * (n - 1) <= x:
			p = min(i, p)
	return p
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	p = divisors(y - x, x, y, n)
	l = list()
	temp = y
	while n > 0:
		l.append(temp)
		temp -= p
		n -= 1
		if temp <= 0:
			break
	while n > 0:
		y = y + p
		l.append(y)
		n -= 1
	print(*l)


T = int(input())
ans = [0] * T
for t in range(T):
	(n, x, y) = map(int, input().split())
	M = 10 ** 5
	true_dif = 0
	for i in range(n - 1):
		for j in range(i + 1, n):
			if (y - x) % (j - i) != 0:
				continue
			dif = (y - x) // (j - i)
			if x - i * dif <= 0:
				continue
			if M > y + (n - 1 - j) * dif:
				M = y + (n - 1 - j) * dif
				true_dif = dif
	ans[t] = list(range(M - (n - 1) * true_dif, M + 1, true_dif))
for a in ans:
	print(*a)


import math
for testcase in range(int(input())):
	(n, a, b) = map(int, input().split())

	def divisors(n):
		(a, b) = ([], [])
		for i in range(1, int(math.sqrt(n)) + 1):
			if n % i == 0:
				if i != n // i:
					a.append(i)
					b.append(n // i)
				else:
					a.append(i)
		a.extend(reversed(b))
		return a
	factors = divisors(abs(b - a))
	final = []
	(t1, t2, m) = (a, b, n)
	for ans in factors:
		(a, b, n) = (t1, t2, m)
		arr = []
		if (b - a) // ans + 1 <= n:
			while n and b > 0:
				arr.append(b)
				b -= ans
				n -= 1
			b = t2
			while n:
				arr.append(b + ans)
				b += ans
				n -= 1
			final.append(arr)
	uv = final[0]
	mn = max(final[0])
	for arr in final:
		x = max(arr)
		if x < mn:
			uv = arr
			mn = x
	print(*uv)


for _ in range(int(input())):
	(x, a, b) = map(int, input().split())
	y = b - a
	ans = [b, a]
	for i in range(x - 1, 0, -1):
		if y % i == 0:
			t = i
			break
	for i in range(t - 1):
		k = ans[-1] + y // t
		ans.append(k)
	k = len(ans)
	t = abs(ans[-1] - ans[-2])
	p = 0
	a -= 1
	for i in range(x - k):
		if a >= t:
			ans.append(a - t + 1)
			a -= t
		else:
			ans.append(b + t)
			b += t
	print(*ans)


import math
numbers = {}
t = int(input())
for i in range(0, t, 1):
	ip_string = input()
	nums = [int(n) for n in ip_string.split()]
	x = nums[0]
	a = nums[1]
	b = nums[2]
	if x == 2:
		print(str(a) + ' ' + str(b))
	else:
		difference = b - a
		multiples = [1]
		for i in range(x - 1, 0, -1):
			if difference % i == 0:
				multiples[0] = i
				break
		d = difference / multiples[0]
		start_offset = a - d
		count = 0
		limit = x - (multiples[0] + 1)
		ans = []
		while start_offset > 0 and count < limit:
			ans.append(start_offset)
			start_offset -= d
			count = count + 1
		ans.append(a)
		count = count + 1
		for i in range(count, x, 1):
			ans.append(ans[-1] + d)
		for i in ans:
			print(int(i), end=' ')
		print()


t = int(input())
while t:
	t -= 1
	(n, x, y) = map(int, input().split())
	k = y - x
	a = []
	for i in range(1, k + 1):
		if k % i == 0:
			a.append(i)
	ans = [x]
	ll = 10 ** 9
	for i in a:
		if n >= (y - x) / i + 1:
			ll = i
			break
	a = ll
	while ans[-1] < y and len(ans) < n:
		ans.append(ans[-1] + a)
	while len(ans) < n and ans[0] > 0:
		if ans[0] - a > 0:
			ans = [ans[0] - a] + ans
		else:
			break
	while len(ans) < n:
		ans.append(ans[-1] + a)
	print(*ans, sep=' ')


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = [1000000000000] * n
	for i in range(1, y, 1):
		a = []
		b = []
		tmp = y
		c = 0
		while tmp > 0 and c < n:
			a.append(tmp)
			tmp -= i
			c += 1
		nn = len(a)
		c = 1
		while nn < n:
			b.append(y + i * c)
			c += 1
			nn += 1
		fin = a[::-1] + b
		if x in fin and y in fin and (fin[-1] < ans[-1]):
			ans = fin[:]
	print(*ans)


import math
for i in range(int(input())):
	(n, x, y) = [*map(int, input().split())]
	multiple = y - x
	min_mult = 0
	min_val = float('inf')
	for j in range(1, multiple + 1):
		if multiple % j == 0:
			val = y
			count = 1
			encount = False
			while val > 0 and count <= n:
				count += 1
				if val == x:
					encount = True
				val -= j
			if encount is False:
				continue
			if count > n:
				val += j
			if val > 0:
				min_mult = j
				min_val = y
				break
			else:
				count -= 1
				val = y
				while count <= n:
					val += j
					count += 1
				val -= j
				if val < min_val:
					min_mult = j
					min_val = val
	for j in range(n):
		print(min_val - j * min_mult, end=' ')
	print()


for i in range(int(input())):
	(n, x, y) = map(int, input().split())
	(q, d) = (abs(y - x), [])
	for i in range(n - 1, 0, -1):
		if q % i == 0:
			j = q // i
			break
	a = y - (n - 1) * j
	if a <= 0:
		a += j - int(a / j) * j
	for i in range(n):
		d.append(a + i * j)
	print(*d)


def main():
	t = int(input())
	for _ in range(t):
		(n, x, y) = map(int, input().split())
		d = y - x
		best_max = 1000000000
		(best_start, best_step) = (0, 0)
		for i in range(1, d + 1):
			if d % i != 0:
				continue
			between = d // i + 1
			if n < between:
				continue
			new_n = n - between
			first = max(x % i, x - new_n * i)
			if first == 0:
				first = i
			last = first + i * (new_n - 1)
			if last < best_max:
				best_max = last
				(best_start, best_step) = (first, i)
		for _ in range(n):
			print(best_start, end=' ')
			best_start += best_step
		print()
main()


import sys, collections
tc = int(sys.stdin.readline())
for _ in range(tc):
	(n, a, b) = map(int, sys.stdin.readline().split())
	d = []
	for i in range(1, n + 1):
		for j in range(1, n + 1):
			if i <= j:
				continue
			if (b - a) % (i - j) == 0:
				d.append((i, j, (b - a) // (i - j)))
	d.sort(key=lambda x: x[2])
	ans = []
	for i in range(len(d)):
		a1 = b - (d[i][0] - 1) * d[i][2]
		b1 = a - (d[i][1] - 1) * d[i][2]
		if a1 == b1 and a1 > 0:
			temp = [a1]
			for i in range(n - 1):
				temp.append(temp[-1] + d[0][2])
			if a in temp and b in temp:
				ans.append(temp)
	ans.sort(key=lambda x: max(x))
	print(' '.join(map(str, ans[0])))


def make_arr(s):
	arr = [x]
	i = 0
	while x + i * s != y:
		i += 1
		arr.append(x + i * s)
	return arr
for _ in range(int(input())):
	(n, x, y) = [int(i) for i in input().split()]
	(x, y) = (min(x, y), max(x, y))
	boo = 1
	if n == 2:
		print(x, y)
		continue
	if 1:
		if 1:
			temp1 = n - 1
			ct = abs(x - y)
			while ct % temp1 != 0:
				temp1 -= 1
			s = ct // temp1
			arr = make_arr(s)
			c = len(arr)
			temp = x - s
			if c < n:
				while c < n:
					if temp <= 0:
						break
					else:
						arr.append(temp)
						temp -= s
					c += 1
				temp = y + s
				while c < n:
					arr.append(temp)
					temp += s
					c += 1
		print(*sorted(arr))


import io, os, math
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
rr = lambda : input()
rri = lambda : int(input())
rrm = lambda : list(map(int, input().split()))
INF = float('inf')

def solve(N, x, y):
	best = float('inf')
	ans = []
	for diff in range(1, 51):
		res = [y]
		v = y - diff
		c = N - 1
		reachx = False
		while c > 0 and v > 0:
			res.append(v)
			if v == x:
				reachx = True
			v -= diff
			c -= 1
		largest = y
		if reachx:
			v = y + diff
			while c > 0:
				res.append(v)
				largest = max(largest, v)
				v += diff
				c -= 1
		if largest < best and len(res) == N and reachx:
			ans = res
			best = largest
	return ' '.join(list(map(str, ans)))
t = rri()
for _ in range(t):
	(n, x, y) = rrm()
	print(solve(n, x, y))


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	z = [x, y]
	c = y - x
	d = 0
	if len(z) == n:
		print(*z)
		continue
	for i in range(1, n):
		if c % i == 0:
			d = c // i
	while x - d > 0 and x + d * (n - 1) > y:
		x -= d
	z = [x + d * j for j in range(0, n)]
	print(*z)


t = int(input())

def f(n, x, y, d):
	a = max(1, y - d * (n - 1))
	a += (x - a) % d
	if a <= x:
		return (a + (n - 1) * d, a, d)
	return None
for test in range(t):
	(n, x, y) = [int(z) for z in input().split()]
	d = 1
	result = None
	while d * d <= y - x:
		if (y - x) % d == 0:
			f1 = f(n, x, y, d)
			if f1 is not None and (result is None or f1[0] <= result[0]):
				result = f1
			f2 = f(n, x, y, (y - x) // d)
			if f2 is not None and (result is None or f2[0] <= result[0]):
				result = f2
		d += 1
	(_, a, d) = result
	L = [str(a + d * i) for i in range(n)]
	print(' '.join(L))


t = int(input())
for _ in range(0, t):
	(n, x, y) = map(int, input().strip().split(' '))
	j = n - 1
	while j > 0:
		if (y - x) % j == 0:
			d = int((y - x) / j)
			break
		j -= 1
	i = x
	s = []
	while i < y + 1 and n > 0:
		s.append(i)
		i += d
		n -= 1
	i = x - d
	while i > 0 and n > 0:
		s.append(i)
		i -= d
		n -= 1
	i = y + d
	while n > 0:
		s.append(i)
		i += d
		n -= 1
	s.sort()
	print(*s)


from sys import stdin, stdout

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

def gms():
	return map(str, stdin.readline().strip().split())

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

def gars():
	return list(map(str, stdin.readline().strip().split()))

def gs():
	return stdin.readline().strip()

def gls():
	return list(stdin.readline())

def gi():
	return int(stdin.readline().strip())
t = gi()
while t:
	t -= 1
	(n, x, y) = gmi()
	d = y - x
	fact = []
	for i in range(1, 1 + int(d ** 0.5)):
		v = int(d % i)
		if v == 0:
			if v != i:
				fact.append(i)
				fact.append(d // i)
			else:
				fact.append(i)
	ans = []
	mn = 10000000000.0
	D = d
	for i in fact:
		d = i
		arr = []
		N = n - 2
		c = x - d
		b = D / i - 1
		if N < 0:
			continue
		p = 0
		arr.append(x)
		X = x + d
		while X < y and b > 0 and (N > 0):
			arr.append(X)
			X += d
			N -= 1
			b -= 1
		if N < 0:
			continue
		arr.append(y)
		while c > 0 and N > 0:
			arr.insert(0, c)
			N -= 1
			c -= d
		if N < 0:
			continue
		Y = y
		Y += d
		while N > 0:
			N -= 1
			arr.append(Y)
			Y += d
		if arr[-1] < mn and len(arr) == n:
			brr = [arr[0] + j * d for j in range(n)]
			if arr == brr:
				ans = arr[:]
				mn = arr[-1]
	print(*ans)


t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	if n == 2:
		print(x, y)
	else:
		lol = [x, y]
		z = n - 1
		while z > 0:
			if (y - x) % z == 0:
				break
			else:
				z -= 1
		acc = z - 1
		ss = int((y - x) / z)
		if acc == n - 2:
			r = x + ss
			for i in range(acc):
				lol.append(r)
				r += ss
			print(*lol)
			continue
		needed = n - 2
		if acc < n - 2:
			r = x + ss
			for i in range(acc):
				lol.append(r)
				r += ss
			needed -= acc
			fck = x - ss
			while needed > 0 and fck > 0:
				lol.append(fck)
				fck -= ss
				needed -= 1
			if needed > 0:
				chu = y + ss
				while needed > 0:
					lol.append(chu)
					chu += ss
					needed -= 1
		print(*lol)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	for step in range((y - x - 1) // (n - 1) + 1, y - x + 1):
		if (y - x) % step:
			continue
		smVl = (n - 1) * step
		mx = max(y, smVl)
		if mx == (n - 1) * step:
			for l in range(mx - smVl, mx + 1, step):
				if l >= x:
					mx += x - l + step
					break
		print(*range(mx, mx - n * step, -step))
		break


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	dic = {}
	i = 1
	while i < n:
		if (y - x) % (n - i) == 0:
			break
		i += 1
	diff = (y - x) // (n - i)
	res = []
	cur = x
	while cur <= y:
		res.append(cur)
		cur += diff
	l = len(res)
	rem = n - l
	tmp = rem
	cur = x
	count = 0
	while rem and cur - diff > 0:
		rem -= 1
		cur -= diff
		res.append(cur)
		count += 1
	rem = tmp - count
	cur = y
	while rem:
		cur += diff
		res.append(cur)
		rem -= 1
	print(*res)


tc = int(input())
import math

def factor(n):
	facs = []
	for i in range(1, n // 2 + 1):
		if n % i == 0:
			facs.append(i)
	return facs

def test(x, y, n, f):
	biggest = y
	if y - x > f * (n - 1):
		return (float('inf'), 0, 0)
	n -= (y - x) / f
	n -= 1
	smaller = 0
	bigger = 0
	if n > 0:
		smaller = min(n, int((x - 1) / f))
		n -= int((x - 1) / f)
	if n > 0:
		biggest = y + n * f
		bigger = n
	return (biggest, smaller, bigger)
for _ in range(tc):
	(n, x, y) = [int(x) for x in input().split()]
	diff = y - x
	possible = factor(diff)
	possible.append(diff)
	smallest = float('inf')
	smallesti = 0
	ad = 0
	au = 0
	for (i, e) in enumerate(possible):
		(case, sm, bg) = test(x, y, n, e)
		if case < smallest:
			smallest = case
			smallesti = possible[i]
			ad = sm
	base = x - ad * smallesti
	ans = ''
	while n > 0:
		ans += str(int(base)) + ' '
		base += smallesti
		n -= 1
	print(ans)


t = int(input())
while t:
	t -= 1
	(n, x, y) = map(int, input().split())
	n1 = n
	n -= 1
	while (y - x) % n != 0:
		n -= 1
	d = (y - x) / n
	k = x
	n = n1
	while n > 0 and k <= y:
		print(int(k), end=' ')
		k += d
		n -= 1
	k = x - d
	while n > 0 and k > 0:
		print(int(k), end=' ')
		n -= 1
		k -= d
	k = y + d
	while n > 0:
		print(int(k), end=' ')
		n -= 1
		k += d
	print()


import math

def printDivisors(n):
	list = []
	ans = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				ans.append(i)
			else:
				ans.append(i)
				list.append(int(n / i))
	for i in list[::-1]:
		ans.append(i)
	return ans
T = int(input())
for t in range(T):
	(n, x, y) = map(int, input().split())
	divisors = printDivisors(y - x)
	for d in divisors:
		if (n - 1) * d >= y - x:
			dif = d
			break
	cnt = 0
	while cnt < n:
		print(x, end=' ')
		cnt += 1
		print(y, end=' ')
		cnt += 1
		low = x + dif
		while low < y and cnt < n:
			print(low, end=' ')
			low += dif
			cnt += 1
		low = x - dif
		while low > 0 and cnt < n:
			print(low, end=' ')
			low -= dif
			cnt += 1
		low = y + dif
		while cnt < n:
			print(low, end=' ')
			low = dif + low
			cnt += 1
	print('')


q = int(input())
for _ in range(q):
	[n, x, y] = list(map(int, input().split()))
	d = int(y - x)
	f = []
	for i in range(n):
		f.append(0)
	m = int(10000000000)
	for i in range(d):
		cm = int(0)
		if d % (i + 1) == 0:
			D = int(i + 1)
			a = int((y - x) / D)
			a += 1
			if a <= n:
				b = int((x + D - 1) / D)
				a += b - 1
				if a >= n:
					cm = y
					if cm < m:
						for I in range(n):
							f[I] = y - I * D
						m = cm
				else:
					cm = y + (n - a) * D
					if cm < m:
						for I in range(n):
							f[I] = cm - I * D
						m = cm
	for i in range(n):
		print(f[i], end=' ')
	print(' ')


from math import ceil
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	d = y - x
	mini = d
	for i in range(1, d + 1):
		if d % i == 0 and d // i <= n - 1:
			mini = i
			break
	k = 1 + (y - x) // mini
	diff = n - k
	i = 0
	a1 = x
	while diff > 0:
		if a1 - mini <= 0:
			break
		else:
			diff -= 1
			a1 -= mini
	for i in range(n):
		print(a1 + i * mini, end=' ')
	print()


for _ in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	res = []
	for i in range(0, n - 1):
		if (y - x) % (i + 1) == 0:
			d = (y - x) // (i + 1)
			cnt = min(n, 2 + i + (x - 1) // d)
			m = y + (n - cnt) * d
			if len(res) == 0 or m < res[-1]:
				a = x - min(n - 2 - i, (x - 1) // d) * d
				res = []
				for j in range(n):
					res.append(a)
					a += d
	print(*res)


from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
for i in range(int(input())):
	(n, x, y) = list(map(int, input().split()))
	diff = y - x
	fact = factors(diff)
	finallis = []
	for i in fact:
		lis = []
		if int(diff / i) + 1 > n:
			continue
		else:
			lis = [j for j in range(x, y + 1, int(i))]
			tofill = n - len(lis)
			var = x - int(i)
			while tofill > 0 and var > 0:
				lis.insert(0, var)
				var -= int(i)
				tofill -= 1
			var = y + int(i)
			while tofill > 0:
				lis.append(var)
				var += int(i)
				tofill -= 1
			if len(finallis) == 0:
				finallis = lis
			elif lis[-1] < finallis[-1]:
				finallis = lis
	for i in finallis:
		print(i, end=' ')
	print('')


def func(x, y, n, num, st):
	dif = (y - x) / (n - 1)
	difint = (y - x) // (n - 1)
	if dif == difint:
		if n == num:
			ans = x
			for i in range(n - 1):
				st.append(int(ans))
				ans += dif
			st.append(y)
			return st
		else:
			newdif = num - n
			z = 0
			ans = x
			for i in range(n - 1):
				st.append(int(ans))
				ans += dif
			st.append(y)
			a = x
			while a - dif > 0 and z != newdif:
				a = a - dif
				z += 1
				st.append(int(a))
			if z != newdif:
				b = y
				while z <= newdif - 1:
					b += dif
					st.append(int(b))
					z += 1
				return st
			else:
				return st
	else:
		return func(x, y, n - 1, num, st)
t = int(input())
for h in range(t):
	(n, x, y) = map(int, input().split())
	st = []
	if n == 2:
		print('{} {}'.format(x, y))
	else:
		num = n
		h = func(x, y, n, num, st)
		print(*h)


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')
from collections import Counter
import heapq
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	var = y - x
	maxx = 10 ** 18
	ans = []
	for i in range(1, n):
		if var % i == 0:
			val = var // i
			tt = (n - 1) * val + 1
			for a in range(1, x + 1):
				ind = (y - a) // val
				if (x - a) % val == 0 and (y - a) % val == 0 and (ind >= 1) and (ind <= n - 1):
					if a + (n - 1) * val < maxx:
						maxx = a + (n - 1) * val
						ans = [a, val]
	for i in range(n):
		print(ans[0] + ans[1] * i, end=' ')
	print()


t = int(input())
for i in range(1, t + 1):
	(n, x, y) = map(int, input().split())
	ans = []
	ansT = 10 ** 9 * 50 + 1
	for d in range(1, y - x + 1):
		if (y - x) % d != 0:
			continue
		findx = y
		cur = 1
		tmp = []
		tmp.append(y)
		while cur < n:
			findx -= d
			if findx < x:
				findx += d
				break
			else:
				cur += 1
			tmp.append(findx)
		if x not in tmp:
			continue
		while cur < n:
			findx -= d
			if findx <= 0:
				break
			else:
				cur += 1
			tmp.append(findx)
		findx = y
		while cur < n:
			findx += d
			tmp.append(findx)
			cur += 1
		mmax = max(tmp[0], tmp[-1])
		if mmax < ansT:
			ansT = mmax
			ans = tmp
	print(*ans)


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	d = y - x
	for i in range(1, d + 1):
		if d % i != 0:
			continue
		if d // i + 1 > n:
			continue
		k = min((y - 1) // i, n - 1)
		first = y - k * i
		for j in range(n):
			print(first + j * i, end=' ')
		print()
		break


for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	ans = []
	for d in range(1, y - x + 1):
		if (y - x) % d != 0:
			continue
		res = []
		foundX = False
		cur = y
		need = n
		while cur >= 1 and need > 0:
			res.append(cur)
			if cur == x:
				foundX = True
			need -= 1
			cur -= d
		cur = y
		while need > 0:
			cur += d
			res.append(cur)
			need -= 1
		res = sorted(res)
		if need == 0 and foundX:
			if len(ans) == 0 or ans[-1] > res[-1]:
				ans = res
	print(*ans)


def div(n):
	large_divisors = []
	for i in range(1, int(n ** 0.5 + 1)):
		if n % i == 0:
			large_divisors.append(i)
			if i * i != n:
				large_divisors.append(n // i)
	return large_divisors

def res(n, k):
	mini = 1000000000
	minia0 = 1000000000
	minik = k[0]
	for k0 in k:
		a0 = y - (n - 1) * k0
		if a0 <= 0:
			while a0 <= 0:
				a0 += k0
			if a0 + (n - 1) * k0 < mini:
				mini = a0 + (n - 1) * k0
				minia0 = a0
				minik = k0
		elif a0 <= x:
			for i in range(n):
				print(a0 + k0 * i, end=' ')
			return 0
	for i in range(n):
		print(minia0 + minik * i, end=' ')
	return 0
t = int(input())
for _ in range(t):
	(n, x, y) = map(int, input().split())
	k = div(y - x)
	res(n, k)
	print('')


t = int(input())
for i in range(t):
	(n, x, y) = list(map(int, input().split()))
	diff = 0
	x_pos = 0
	for j in range(1, n):
		if (y - x) % (n - j) == 0:
			diff = int((y - x) / (n - j))
			x_pos = j - 1
			break
	mn = int(x - diff * x_pos)
	while mn <= 0:
		mn += diff
	memo = []
	for _ in range(n):
		memo.append(mn)
		mn += diff
	print(' '.join(list(map(str, sorted(memo)))))


def ans(n, x, y):
	d = -1
	for i in range(n - 1, 0, -1):
		if (y - x) % i == 0:
			d = (y - x) // i
			break
	answer = []
	val = y
	ele = 0
	while val > 0 and ele < n:
		answer.append(val)
		val -= d
		ele += 1
	if ele < n:
		n -= ele
		while n > 0:
			y = y + d
			answer.append(y)
			n -= 1
	s = ''
	for i in answer:
		s += str(i) + ' '
	return s
m = int(input())
for j in range(m):
	arr = input().split()
	n = int(arr[0])
	x = int(arr[1])
	y = int(arr[2])
	print(ans(n, x, y))


from sys import stdin

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

def get_str():
	return stdin.readline().strip()

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

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

def get_array2d(row):
	return [list(map(int, stdin.readline().strip().split())) for _ in range(row)]
T = get_int()
for _ in range(T):
	(n, x, y) = get_ints()
	flag = 0
	add = 1
	while x + add <= y:
		t = add
		for i in range(n - 1):
			if x + t == y:
				flag = 1
				break
			else:
				t += add
		if flag:
			break
		add += 1
	(tx, ty) = (x, y)
	while n > 0 and tx <= y:
		print(tx, end=' ')
		tx += add
		n -= 1
	tx = x
	while n > 0 and tx - add > 0:
		print(tx - add, end=' ')
		tx -= add
		n -= 1
	while n > 0:
		ty += add
		print(ty, end=' ')
		n -= 1
	print()


import math

def factors(num):
	facts = []
	for i in range(1, int(math.sqrt(num) + 1)):
		if num % i == 0:
			if num / i == i:
				facts.append(i)
			else:
				facts.append(i)
				facts.append(num // i)
	facts.sort(reverse=True)
	return facts
for _ in range(int(input())):
	(n, x, y) = map(int, input().split())
	diff = y - x
	ans = []
	max_ans = []
	li = factors(diff)
	if n == 2:
		print(x, y)
	else:
		for item in li:
			newli = []
			newli.append(x)
			a = x
			a = a + item
			while a <= y and len(newli) < n:
				newli.append(a)
				a = a + item
			a = x
			a = a - item
			while a > 0 and len(newli) < n:
				newli.append(a)
				a = a - item
			if len(newli) < n:
				rem = n - len(newli)
				a = y
				while rem != 0:
					a = a + item
					newli.append(a)
					rem = rem - 1
			if x in newli and y in newli:
				ans.append(newli)
				max_ans.append(max(newli))
		ele = min(max_ans)
		pos = max_ans.index(ele)
		fans = ans[pos]
		for item in fans:
			print(item, end=' ')
		print('')


tmp = int(input())

def primes_set(n):
	result = []
	for i in range(2, int(n ** (1 / 2)) + 1):
		if n % i == 0:
			result.append(i)
			result.append(n // i)
	result.append(1)
	result.append(n)
	return sorted(result)

def solve(n, x, y):
	if n == 2:
		print(x, y)
	else:
		my_set = primes_set(y - x)
		result = None
		for num in my_set:
			if (y - x) // num < n:
				result = num
				break
		arr = []
		counter = 0
		while n > 0:
			if y - counter * result <= 0:
				break
			arr.append(str(y - counter * result))
			counter += 1
			n -= 1
		counter = 1
		while n > 0:
			arr.append(str(y + counter * result))
			counter += 1
			n -= 1
		print(' '.join(arr))
for i in range(tmp):
	(n, x, y) = map(int, input().split())
	solve(n, x, y)


def ok(n, x, y):
	if n == 2:
		return [x, y]
	b = [1000000000 for x in range(n)]
	for i in range(n - 1):
		arr = [-1 for p in range(n)]
		for j in range(i + 1, n):
			arr[i] = x
			diff = y - x
			dis = j - i
			if diff % dis == 0:
				arr[j] = y
				diff = diff // dis
				for k in range(i - 1, -1, -1):
					arr[k] = arr[k + 1] - diff
				for k in range(i + 1, n):
					arr[k] = arr[k - 1] + diff
				if arr[0] > 0 and arr[-1] < b[-1]:
					b = arr
	return b
n = int(input())
for i in range(n):
	(n, x, y) = map(int, input().split())
	ans = ok(n, x, y)
	for i in ans:
		print(i, end=' ')


from collections import Counter, defaultdict as dft

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

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

def solve():
	(n, x, y) = mp()
	mx = 10 ** 9
	diff = y - x
	for l in range(1, 50):
		for r in range(l + 1, 51):
			if diff % (r - l) == 0:
				d = diff // (r - l)
				a = x - d * (l - 1)
				if a > 0 and a + (n - 1) * d < mx and (a + (n - 1) * d >= y):
					mx = a + (n - 1) * d
					ra = a
					rd = d
	res = []
	for i in range(n):
		res.append(ra + rd * i)
	print(*res)
t = int(input())
for _ in range(t):
	solve()