Problem: 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 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = 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, ..., a_n).

You have to answer t independent test cases.

Input

The first line of the input contains one integer t (1 ≤ t ≤ 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 ≤ n ≤ 50; 1 ≤ x < y ≤ 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, ..., a_n (1 ≤ a_i ≤ 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 

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Random;
import java.util.StringTokenizer;

// CFPS -> CodeForcesProblemSet
public final class CFPS {
	static FastReader fr = new FastReader();
	static PrintWriter out = new PrintWriter(System.out);
	static final int gigamod = 1000000007;

	public static void main(String[] args) {
		int t = fr.nextInt();
		OUTER: 
		for (int tc = 0; tc < t; tc++) {
			int n = fr.nextInt(), x = fr.nextInt(), y = fr.nextInt();

			// It is crucial to understand that the difference between
			// the values of the target array is bound by the difference
			// between x and y.
			// Case 1: x and y are consecutive -> The difference is (y-x).
			// Case 2: x and y not consecutive -> The difference is (y-x)/i.

			// The upper limit to the difference in target array is (y-x).
			// The lower limit is 1.

			// What values can difference take?
			// A: (y-x)/1, (y-x)/2, .... 1 (only the integer values).

			// What can we do with all this information?
			// A: Try out until we get some difference that works!

			int[] validDiffs = new int[(y - x)];
			int lctr = 0;
			for (int i = 1; i < (y - x) + 1; i++) {
				if ((y - x) % i == 0)
					validDiffs[lctr++] = i;
			}
			
			// Just brute force through every valid diff.
			int bestDiff = -1;
			long minLast = Integer.MAX_VALUE;
			for (int diff : validDiffs) {
				if (diff == 0) break;
				int nCtr = n;
				
				// Fitting elements between x and y.
				nCtr -= ((y - x)/diff + 1);
				
				if (nCtr == 0) {
					bestDiff = diff;
					minLast = y;
					break;
				}
				
				if (nCtr < 0) {
					continue;
				}
				
				// Fitting elements before x.
				if (x % diff == 0)
					nCtr -= (x/diff - 1);
				else
					nCtr -= (x/diff);
				
				if (nCtr <= 0) {
					bestDiff = diff;
					minLast = y;
					break;
				}
				
				// Fitting elements after y.
				int lastElem = y;
				for (int i = 0; i < nCtr; i++) 
					lastElem += diff;
				
				if (lastElem < minLast) {
					minLast = lastElem;
					bestDiff = diff;
					break;
				}
			}
			
			// Generating the array.
			long[] arrl = new long[n];
			int arrCtr = 0;
			long start = x;
			int nCtr = n;
			
			// Fitting between x and y.
			while (start <= y) {
				if (arrCtr >= n) {
					// out.println(start);
					break;
				}
				arrl[arrCtr++] = start;
				nCtr--;
				start += bestDiff;
			}
			
			// Fitting before x.
			start = x;
			while (start > 0 && nCtr > 0) {
				if (start != x) {
					nCtr--;
					arrl[arrCtr++] = start;
				}
				
				start -= bestDiff;
			}
			
			// Fitting after y if any.
			start = y + bestDiff;
			for (int i = 0; i < nCtr; i++) {
				arrl[arrCtr++] = start;
				start += bestDiff;
			}
			
			for (long i : arrl)
				if (i != 0)
					out.print(i + " ");
			out.println();
		}
		out.close();
	}

	static class Tuple implements Comparable<Tuple> {
		int a;
		int b;
		int c;

		Tuple() {
			a = b = 0;
		}

		Tuple(int a, int b, int c) {
			this.a = a;
			this.b = b;
			this.c = c;
		}

		@Override
		public int compareTo(CFPS.Tuple o) {
			if (this.a > o.a)
				return -1;
			if (this.a < o.a)
				return 1;
			return 0;
		}
	}

	static class customTupleComparator implements Comparator<Tuple> {
		@Override
		public int compare(CFPS.Tuple o1, CFPS.Tuple o2) {
			if (o1.b > o2.b)
				return 1;
			if (o1.b < o2.b)
				return -1;
			return 0;
		}
	}

	// Returns the index of the element just larger than
	// or equal to the val.
	static int bsearch(int[] arr, int val) {
		int idx = -1;
		int lo = 0, hi = arr.length - 1;
		while (lo <= hi) {
			int mid = lo + (hi - lo) / 2;
			if (arr[mid] >= val) {
				idx = mid;
				hi = mid - 1;
			} else
				lo = mid + 1;
		}
		return idx;
	}

	static int bsearch(long[] arr, long val) {
		int idx = -1;
		int lo = 0, hi = arr.length - 1;
		while (lo <= hi) {
			int mid = lo + (hi - lo) / 2;
			if (arr[mid] >= val) {
				idx = mid;
				hi = mid - 1;
			} else
				lo = mid + 1;
		}
		return idx;
	}

	static int factorial(int n) {
		if (n <= 1)
			return 1;
		return n * factorial(n - 1);
	}

	static long factorialInDivision(long a, long b) {
		if (a == b)
			return 1;
		return a * factorialInDivision(a - 1, b);
	}

	static BigInteger factorialInDivision(BigInteger a, BigInteger b) {
		if (a.equals(b))
			return BigInteger.ONE;
		return a.multiply(factorialInDivision(a.subtract(BigInteger.ONE), b));
	}

	// Sieve of Eratosthenes:
	static boolean[] primeGenerator(int upto) {
		boolean[] isPrime = new boolean[upto + 1];
		Arrays.fill(isPrime, true);
		isPrime[1] = isPrime[0] = false;

		for (long i = 2; i * i < upto + 1; i++)
			if (isPrime[(int) i])
				// Mark all the multiples greater than or equal
				// to the square of i to be false.
				for (long j = i; j * i < upto + 1; j++)
					isPrime[(int) j * (int) i] = false;
		return isPrime;
	}

	static int gcd(int a, int b) {
		if (b == 0) {
			return a;
		} else {
			return gcd(b, a % b);
		}
	}

	static boolean less(int a, int b) {
		return a < b ? true : false;
	}

	static void swap(int[] a, int i, int j) {
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}

	static boolean isSorted(int[] a) {
		for (int i = 1; i < a.length; i++) {
			if (less(a[i], a[i - 1]))
				return false;
		}
		return true;
	}

	static void shuffleArray(long[] arr, int startPos, int endPos) {
		Random rnd = new Random();
		for (int i = startPos; i < endPos; ++i) {
			long tmp = arr[i];
			int randomPos = i + rnd.nextInt(endPos - i);
			arr[i] = arr[randomPos];
			arr[randomPos] = tmp;
		}
	}

	static void shuffleArray(int[] arr, int startPos, int endPos) {
		Random rnd = new Random();
		for (int i = startPos; i < endPos; ++i) {
			int tmp = arr[i];
			int randomPos = i + rnd.nextInt(endPos - i);
			arr[i] = arr[randomPos];
			arr[randomPos] = tmp;
		}
	}

	static void shuffleArray(double[] arr, int startPos, int endPos) {
		Random rnd = new Random();
		for (int i = startPos; i < endPos; ++i) {
			double tmp = arr[i];
			int randomPos = i + rnd.nextInt(endPos - i);
			arr[i] = arr[randomPos];
			arr[randomPos] = tmp;
		}
	}

	// Time Complexity: O(sqrt(n))
	static boolean isPrime(int n) {
		if (n <= 1)
			return false;
		if (n <= 3)
			return true;

		if (n % 2 == 0 || n % 3 == 0)
			return false;

		for (int i = 5; i * i <= n; i = i + 6)
			if (n % i == 0 || n % (i + 2) == 0)
				return false;

		return true;
	}

	static String toString(int[] dp) {
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < dp.length; i++)
			sb.append(dp[i] + " ");
		return sb.toString();
	}
	
	static String toString(long[] dp) {
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < dp.length; i++)
			sb.append(dp[i] + " ");
		return sb.toString();
	}

	static String toString(int[][] dp) {
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < dp.length; i++) {
			for (int j = 0; j < dp[i].length; j++) {
				sb.append(dp[i][j] + " ");
			}
			sb.append('\n');
		}
		return sb.toString();
	}

	static String toString(double[][] dp) {
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < dp.length; i++) {
			for (int j = 0; j < dp[i].length; j++) {
				sb.append(dp[i][j] + " ");
			}
			sb.append('\n');
		}
		return sb.toString();
	}

	// Uniform hashing into array.
	static int hash(String s, int arrayLen) {
		return (s.hashCode() & 0x7fffffff) % arrayLen;
	}

	static int hash(Integer s, int arrayLen) {
		return (s.hashCode() & 0x7fffffff) % arrayLen;
	}

	static int hash(Long s, int arrayLen) {
		return (s.hashCode() & 0x7fffffff) % arrayLen;
	}

	static int hash(Double s, int arrayLen) {
		return (s.hashCode() & 0x7fffffff) % arrayLen;
	}

	static class FastReader {
		private BufferedReader bfr;
		private StringTokenizer st;

		public FastReader() {
			bfr = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			if (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(bfr.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		char nextChar() {
			return next().toCharArray()[0];
		}

		String nextString() {
			return next();
		}

		int[] nextIntArray(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++)
				arr[i] = nextInt();
			return arr;
		}

		int[] nextOneIntArray(int n) {
			int[] arr = new int[n + 1];
			for (int i = 1; i < n; i++)
				arr[i] = nextInt();
			return arr;
		}

		double[] nextDoubleArray(int n) {
			double[] arr = new double[n];
			for (int i = 0; i < arr.length; i++)
				arr[i] = nextDouble();
			return arr;
		}

		long[] nextLongArray(int n) {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++)
				arr[i] = nextLong();
			return arr;
		}

		public char[] nextCharArray(int n) {
			char[] chars = new char[n];
			for (int i = 0; i < n; i++)
				chars[i] = fr.nextChar();
			return chars;
		}
	}
}