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: introductory

Starter code:

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


def read_ints():
    return list(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


t = int(input())
# a = list(map(int, input().split()))
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


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)

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

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 = list(map(int,input().split()))
        solve(n,x,y,ans)

    for i in ans:
        print(' '.join(i))
        

main()


# Fast IO (be careful about bytestring)

# import os,io
# input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline

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


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)

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
 
#sys.setrecursionlimit(10**6)
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()			


t = int(input())
while t>0:
  n,x,y = list(map(int,input().split()))
  min_val = 1e5
  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


#!/usr/bin/env pypy3

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 collections import defaultdict as dd
import sys
input=sys.stdin.readline
t=int(input())
while t:
    #n=int(input())
    n,x,y=list(map(int,input().split()))
    #l=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
                   
        
    


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)

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 bisect
import copy
import fractions
import functools
import heapq
import math
import random
import sys


def __starting_point():

    T = int(input())

    for t in range(T):
        N, X, Y = tuple(map(int, input().split()))

        # Find smallest possible difference between adjacent elements
        for div in range(1, (Y - X) + 1):
            if (Y - X) % div == 0 and div * (N - 1) >= (Y - X):
                break

        # Find minimal range
        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)))

__starting_point()

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