Given $n$, find any array $a_1, a_2, \ldots, a_n$ of integers such that all of the following conditions hold:

$1 \le a_i \le 10^9$ for every $i$ from $1$ to $n$.

$a_1 < a_2 < \ldots <a_n$

For every $i$ from $2$ to $n$, $a_i$ isn't divisible by $a_{i-1}$

It can be shown that such an array always exists under the constraints of the problem.


-----Input-----

The first line contains the number of test cases $t$ ($1 \le t \le 100$). Description of the test cases follows.

The only line of each test case contains a single integer $n$ ($1 \le n \le 1000$).

It is guaranteed that the sum of $n$ over all test cases does not exceed $10^4$.


-----Output-----

For each test case print $n$ integers $a_1, a_2, \ldots, a_n$ — the array you found. If there are multiple arrays satisfying all the conditions, print any of them.


-----Examples-----

Input
3
1
2
7
Output
1
2 3
111 1111 11111 111111 1111111 11111111 111111111


-----Note-----

In the first test case, array $[1]$ satisfies all the conditions.

In the second test case, array $[2, 3]$ satisfies all the conditions, as $2<3$ and $3$ is not divisible by $2$.

In the third test case, array $[111, 1111, 11111, 111111, 1111111, 11111111, 111111111]$ satisfies all the conditions, as it's increasing and $a_i$ isn't divisible by $a_{i-1}$ for any $i$ from $2$ to $7$.

Difficulty: EASY
Tags: Mathematics

Constructive algorithms

Starter code:

Solutions:
for i in range(int(input())):
	a = int(input())
	for j in range(2, a + 2):
		print(j, end=' ')
	print('\n', end='')


t = int(input())
for i in range(t):
	n = int(input())
	ans = [int(j + 2) for j in range(n)]
	print(*ans)


for _ in range(int(input())):
	n = int(input())
	al = []
	for i in range(n):
		al.append(i + 2)
	print(*al)


testcases = int(input())
for i in range(testcases):
	n = int(input())
	for i in range(2, n + 2, 1):
		print(i, end=' ')
	print()


def solve():
	n = int(input())
	arr = []
	start = 0
	while True:
		for a in range(1, 10 ** 9):
			arr.append(a)
			for i in range(1, len(arr)):
				if arr[i] % arr[i - 1] == 0:
					start = max(arr)
					arr.clear()
					break
			if len(arr) == n:
				return arr

def main():
	test_cases = int(input())
	for _ in range(test_cases):
		print(' '.join(map(str, solve())))
main()


t = int(input())
for _ in range(t):
	n = int(input())
	for i in range(2, n + 2):
		print(i, end=' ')
	print('')


import os
from math import ceil, factorial, log
import sys
from collections import Counter
from itertools import permutations
from io import BytesIO, IOBase, StringIO

def highestPowerOf2(n):
	return n & ~(n - 1)

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

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

def calc(max_idx, n, arr):
	cnt = 0
	count = 0
	cnt_odd = 0
	for j in range(n):
		if j != max_idx:
			if arr[j] % 2 == 0:
				cnt += log(highestPowerOf2(arr[j])) / log(2)
				count += 1
			else:
				cnt_odd += arr[j]
	return arr[max_idx] * 2 ** cnt + count + cnt_odd

def main():
	for i in range(int(input())):
		n = int(input())
		x = 2
		for j in range(n):
			print(x, end=' ')
			x += 1
		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()


n = int(input())
for i in range(n):
	a = int(input())
	s = str()
	for i in range(2, a + 2):
		s += str(i) + ' '
	print(s)


import itertools
from math import floor, log, log2, ceil, sqrt
from itertools import groupby
from decimal import Decimal, getcontext
import sys
from collections import deque
primes = set()
maxN = 1000001

def generatePrimes():
	used = [False] * maxN
	for i in range(2, maxN):
		if not used[i]:
			primes.add(i)
			for j in range(i, maxN, i):
				used[j] = True

def isPrime(n):
	if n < 2:
		return True
	x = 2
	while x * x <= n:
		if n % x == 0:
			return False
		x += 1
	return True
t = int(input())
res = []
for _ in range(t):
	n = int(input())
	ans = ' '.join(map(str, range(2, n + 2)))
	res.append(ans)
for i in range(t):
	print(res[i])


def findarray(n):
	if n == 1:
		return [1]
	arr = [i for i in range(2, n + 2)]
	return arr
t = int(input())
ans = []
while t != 0:
	n = int(input())
	ans.append(findarray(n))
	t -= 1
for i in ans:
	for j in i:
		print(j, end=' ')
	print(' ')


res = []
t = int(input())
for i in range(t):
	n = int(input())
	res.append(n)
for r in res:
	arr = [str(i + 2) for i in range(r)]
	print(' '.join(arr))


t = int(input())
for _ in range(t):
	n = int(input())
	A = [3]
	for i in range(1, n):
		temp = 1
		while (A[-1] + temp) % A[-1] == 0:
			temp += 1
		A.append(A[-1] + temp)
	A = ' '.join(list(map(lambda x: str(x), A)))
	print(A)


for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print(1)
	else:
		arr = []
		x = 2
		for i in range(1, n + 1):
			arr.append(x)
			x += 1
		print(*arr)


import sys
from math import factorial, gcd
from collections import Counter, deque, defaultdict
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush, heapify, nlargest, nsmallest
from itertools import groupby
from copy import deepcopy
MOD = 10 ** 9 + 7
INF = float('inf')
input = sys.stdin.readline
rl = lambda : list(map(int, input().split()))
rs = lambda : sys.stdin.readline().strip()
arr = []
i = 1
while len(arr) < 1000:
	i += 2
	for k in range(2, 1 + int((i + 1) ** 0.5)):
		if i % k == 0:
			break
	else:
		arr.append(i)
for _ in range(int(input())):
	n = int(input())
	print(*arr[:n])


import sys
for _ in range(int(input())):
	n = int(input())
	arr = list(range(2, n + 2))
	sys.stdout.write(' '.join(map(str, arr)) + '\n')


n = int(input())
for i in range(n):
	x = int(input())
	s = 0
	p = 3
	while s != x:
		print(p, end=' ')
		s += 1
		p += 1
	print()


def solve():
	tong = 0
	n = int(input())
	for i in range(2, n + 2):
		print(i, end=' ')
		tong += i
	print()
for i in range(int(input())):
	solve()


from collections import Counter
from math import ceil, floor, log
import bisect as bs
import sys
input = sys.stdin.readline
inp_lis = lambda : list(map(int, input().split()))
inp_multi = lambda : map(int, input().split())
inp_int = lambda : int(input().strip())
for _ in range(int(input().strip())):
	n = inp_int()
	for x in range(n, 2 * n):
		print(x, end=' ')
	print()


for _ in range(int(input())):
	n = int(input())
	for i in range(n):
		print((i + 2) % 100000000, end=' ')
	print('')


n = int(input())
for i in range(n):
	a = int(input())
	count = 2
	for i in range(a):
		print(count, end=' ')
		count = count + 1
	print()


from sys import stdin
for testcase in range(int(stdin.readline())):
	length = int(stdin.readline())
	print(*[2 + value for value in range(length)])


import sys
input = sys.stdin.readline

def prime_gen(k):
	c = [False] * k
	for i in range(k):
		if not c[i]:
			yield (i + 2)
			c[i::i + 2] = [True] * len(c[i::i + 2])
p = list(prime_gen(100000))
t = int(input())
for _ in range(t):
	n = int(input())
	print(*p[:n])


problem_num = int(input())
for i in range(problem_num):
	num = int(input())
	lst = []
	for i in range(2, 2 + num):
		lst.append(str(i))
	lst = ' '.join(lst)
	print(lst)


t = int(input())
for _ in range(t):
	n = int(input())
	ans = list()
	for i in range(n, 2 * n):
		ans.append(i)
	print(*ans)


t = int(input())
for _ in range(t):
	n = int(input())
	arr = []
	if n == 1:
		print(1)
	else:
		arr = []
		i = 2
		if n % 2 == 0:
			while i < n + 1:
				if (i + 1) % i != 0:
					arr.append(str(i))
					arr.append(str(i + 1))
				i += 2
			output = ' '.join(arr)
			print(output)
		else:
			for j in range(2, n + 2, 2):
				if j + 1 % j != 0:
					arr.append(str(j))
					arr.append(str(j + 1))
			arr.pop(-1)
			output = ' '.join(arr)
			print(output)


import sys
t = int(input())
for _ in range(t):
	n = int(input())
	s = 2
	print(s, end=' ')
	for k in range(n - 1):
		print(s + 1, end=' ')
		s = s + 1
	print('')


t = int(input())
for i in range(t):
	n = int(input())
	a = [int(j + 2) for j in range(n)]
	print(*a)


t = int(input())
for i in range(t):
	a = int(input())
	b = []
	for i in range(2, a + 2):
		b.append(i)
	print(*b)


def solve(n):
	return [i for i in range(2, n + 2)]
ans = []
for _ in range(int(input())):
	ans.append(solve(int(input())))
for a in ans:
	print(*a)


a = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919]
for i in range(int(input())):
	b = int(input())
	for i in range(b):
		print(a[i], end=' ')


for _ in range(int(input())):
	print(*[i for i in range(2, int(input()) + 2)])


tests = int(input())
for _ in range(tests):
	n = int(input())
	n += 1
	a = [i for i in range(2, n + 1)]
	print(*a)


total = int(input())
nums = []
for i in range(total):
	nums.append(int(input()))
maxlen = max(nums)
res = [3]
for i in range(maxlen):
	res.append(res[-1] + 2)
for num in nums:
	for i in res[0:num - 1]:
		print(i, end=' ')
	print(res[num - 1])


for _ in range(int(input())):
	n = int(input())
	a = []
	for i in range(3, n * 2 + 2):
		if i % 2 != 0:
			a.append(i)
	print(*a)


import math
import os
import sys
from io import BytesIO, IOBase
M = 1000000007
import random
import heapq
import threading
import bisect
import time
from functools import *
from collections import *
from itertools import *
BUFSIZE = 8192
import array

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def 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 fsep():
	return map(float, inp().split())

def inpu():
	return int(inp())

def build(a, b, st, arr, node):
	if a == b:
		st[node] = arr[a]
		return arr[a]
	mid = (a + b) // 2
	p = build(a, mid, st, arr, 2 * node + 1)
	q = build(mid + 1, b, st, arr, 2 * node + 2)
	st[node] = p + q
	return st[node]

def update(st, a, b, x, val, node):
	if x < a or x > b:
		return
	st[node] = st[node] + val
	if a != b:
		mid = (a + b) // 2
		update(st, a, mid, x, val, 2 * node + 1)
		update(st, mid + 1, b, x, val, 2 * node + 2)

def getsum(st, a, b, l, r, node):
	if l > b or r < a:
		return 0
	if l <= a and r >= b:
		return st[node]
	mid = (a + b) // 2
	return getsum(st, a, mid, l, r, 2 * node + 1) + getsum(st, mid + 1, b, l, r, 2 * node + 2)

def dfs2(curr, parent, start, end, cnt, res, d, arr):
	res[cnt[0]] = arr[curr - 1]
	start[curr] = cnt[0]
	cnt[0] += 1
	for i in d[curr]:
		if i != parent:
			dfs2(i, curr, start, end, cnt, res, d, arr)
			cnt[0] += 1
	res[cnt[0]] = arr[curr - 1]
	end[curr] = cnt[0]

def prime(n):
	for i in range(2, n):
		if n % i == 0:
			return False
	return True

def main():
	t = 1
	t = inpu()
	for _ in range(t):
		n = inpu()
		ans = []
		flag = 0
		while True:
			for i in range(2, 10000):
				if prime(i) == True:
					ans.append(i)
				if len(ans) == n:
					flag = 1
					break
			if flag == 1:
				break
		print(*ans)
main()


for t in range(int(input())):
	n = int(input())
	answer = []
	for i in range(n, n * 2):
		answer.append(i)
	print(*answer)


for caseno in range(int(input())):
	n = int(input())
	a = [2 + i for i in range(n)]
	print(*a)


import sys
T = int(sys.stdin.readline().strip())
for t in range(T):
	n = int(sys.stdin.readline().strip())
	a = [str(i + 2) for i in range(0, n)]
	print(' '.join(a))


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	for i in range(2, int(input()) + 2):
		print(i, end=' ')
	print()


t = int(input())
for _ in range(t):
	a = int(input())
	count = 2
	while a != 0:
		print(count, end=' ')
		count += 1
		a -= 1
	print()


t = int(input())
while t:
	n = int(input())
	a = 2
	li = []
	for i in range(n):
		li.append(a)
		a += 1
	print(*li)
	t -= 1


t = int(input())
for i in range(t):
	n = int(input())
	for k in range(n):
		print(k + 2)


import sys, os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
import math
import bisect
t = int(input())
for a0 in range(t):
	n = int(input())
	l = []
	for i in range(2, n + 2):
		l.append(i)
	print(*l)


for _ in range(int(input())):
	n = int(input())
	for i in range(1, n + 1):
		print(i + 1, end=' ')
	print()


from math import *
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 __init__(self):
		self.ans = 0

	def solve(self, a):
		x = []
		for i in range(2, a + 2):
			x.append(i)
		return x
sol = Solution()
t = inp()
k = t
ans = []
while t:
	x = inp()
	ans.append(sol.solve(x))
	t -= 1
for i in range(k):
	for j in range(len(ans[i])):
		print(ans[i][j], end=' ')
	print(end='\n')


for _ in range(int(input())):
	print(*list(range(2, int(input()) + 2)))


t = int(input())
for i in range(t):
	n = int(input())
	ok = 2
	for i in range(n):
		print(ok)
		ok += 1


t = int(input())
for i in range(t):
	n = int(input())
	for j in range(n, n * 2):
		print(j, end=' ')
	print()


t = int(input())
for i in range(t):
	n = int(input())
	l = []
	x = 2
	for j in range(n):
		l.append(x)
		y = x
		while y % x == 0:
			y += 1
		x = y
	print(*l)


def solve():
	n = int(input())
	print(*[x for x in range(2, n + 2)])
t = int(input())
for tc in range(t):
	solve()


T = int(input())
for tc in range(T):
	k = int(input())
	c = []
	for i in range(2, k + 2):
		c.append(i)
	print(*c)


import sys
import math

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

def in1():
	return int(input())
for _ in range(in1()):
	n = in1()
	a = []
	for i in range(n):
		a.append(i + 2)
	print(*a)


n = int(input())
for i in range(n):
	x = int(input())
	if x == 1:
		print('1')
	else:
		ans = ''
		for j in range(x, 2 * x):
			ans += str(j) + ' '
		print(ans)


t = int(input())
for i in range(t):
	a = []
	n = int(input())
	s = 2
	for i in range(n):
		a.append(s)
		s = s + 1
	print(*a, sep=' ')


for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print(1)
	else:
		for i in range(2, n + 2):
			print(i, end=' ')
		print()


n = int(input())
for i in range(n):
	num = int(input())
	for j in range(2, num + 2):
		print(j, end=' ')


t = int(input())
for i in range(t):
	n = int(input())
	arr = []
	if n == 1:
		print(1)
	else:
		arr.append(2)
		i = 1
		while 1:
			if len(arr) == n:
				break
			arr.append(arr[i - 1] + 1)
			i += 1
		for k in arr:
			print(k, end=' ')
		print(end='\n')


t = int(input())
n = []
for i in range(t):
	n.append(input())
for i in n:
	if int(i) == 1:
		print(1)
	elif int(i) == 2:
		print('2 3')
	else:
		a = ''
		for j in range(2, int(i) + 2):
			a += str(j) + ' '
		a = a[0:-1]
		print(a)


import math

def test():
	temp = int(input())
	otv = str()
	for i in range(2, temp + 2):
		otv += str(i) + ' '
	print(otv)
t = int(input())
for i in range(t):
	test()


T = int(input())
for test in range(T):
	n = int(input())
	for i in range(n):
		print(i + 2, end=' ')
	print()


l = []

def SieveOfEratosthenes(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
	for p in range(2, n + 1):
		if prime[p]:
			l.append(p)
n = 10 ** 5
SieveOfEratosthenes(n)
for _ in range(0, int(input())):
	a = int(input())
	print(*l[:a])


from sys import stdin, stdout
ip = lambda : stdin.readline().rstrip('\r\n')
ips = lambda : ip().split()
mp = lambda : map(int, ips())
ls = lambda : list(mp())
out = lambda x, end='\n': stdout.rWite(f'{x}{end}')
mod = 1000000007
for _ in range(int(ip())):
	n = int(ip())
	a = []
	for i in range(2, n + 2):
		a.append(i)
	print(*a)


for t in range(int(input())):
	n = int(input())
	arr = []
	for i in range(1, n + 1):
		arr.append(i + 1)
	print(*arr)


T = int(input())
for _ in range(T):
	n = int(input())
	for i in range(n):
		print(i + 2, end=' ')
	print()


for i in range(int(input())):
	n = int(input())
	print(' '.join([str(x) for x in range(2, n + 2)]))


for i in range(int(input())):
	n = int(input())
	l = []
	if n == 1:
		print('1')
	else:
		for i in range(2, n + 2):
			l.append(i)
		for i in range(len(l)):
			l[i] = str(l[i])
		s = ' '.join(l)
		print(s)


t1 = int(input())
for _ in range(t1):
	n = int(input())
	for i in range(2, n + 2):
		print(i, end=' ')
	print()


for _ in range(int(input())):
	c = int(input())
	if c == 1:
		print(1)
	else:
		a = 2
		for i in range(c):
			print(a, end=' ')
			a += 1
		print()


for i in range(int(input())):
	n = int(input())
	for i in range(n):
		print(i + 2, end=' ')
	print()


for _ in range(int(input())):
	n = int(input())
	a = range(2, n + 2)
	print(*a)


for i in range(int(input())):
	n = int(input())
	arr = []
	for i in range(n):
		arr.append(i + 2)
	print(*arr)


def solve(n):
	return [e + 1 for e in range(1, n + 1)]
t = int(input())
while t:
	n = int(input())
	print(*solve(n))
	t -= 1


def solve(n):
	res = []
	for i in range(1, n + 1):
		if i == 1:
			res.append(3)
			continue
		res.append(i ** 2)
	return res
for _ in range(int(input())):
	n = int(input())
	print(*solve(n))


t = int(input())
for i in range(t):
	a = int(input())
	l = list(range(2, a + 2))
	l.append('\n')
	for j in l:
		print(j, end=' ')


for _ in range(int(input())):
	n = int(input())
	print(*[x for x in range(2, 2 + n)])


def main():
	T = int(input())
	for t in range(T):
		n = int(input())
		print(' '.join(map(str, range(2, n + 2))))
main()


from math import sqrt

def isPrime(n):
	prime_flag = 0
	if n > 1:
		for i in range(2, int(sqrt(n)) + 1):
			if n % i == 0:
				prime_flag = 1
				break
		if prime_flag == 0:
			return True
		else:
			return False
	else:
		return False
t = int(input())
for t1 in range(t):
	arr = []
	l = int(input())
	i = 2
	while len(arr) < l:
		if isPrime(i):
			arr.append(i)
		i += 1
	for x in arr:
		print(x, end=' ')


n = int(input())
num = []
for i in range(n):
	a = int(input())
	num.append(a)
for i in range(n):
	lst = []
	res = ''
	a = num[i]
	while len(lst) < a + 1:
		if len(lst) == 0:
			lst.append(1)
		elif len(lst) == 1:
			lst.append(2)
		else:
			lst.append(lst[-1] + 1)
		res = res + str(lst[-1]) + ' '
	print(res[2:-1])


n = int(input())
temp = []
for i in range(n):
	a = input()
	temp.append(int(a))
res = []
nums = []
for i in range(n):
	j = 3
	a = len(nums)
	while a != temp[i]:
		nums.append(j)
		j += 2
		a = len(nums)
	res.append(nums[:])
	nums.clear()
for i in range(len(res)):
	for j in range(len(res[i])):
		print(res[i][j], end=' ')
	print('')


t = int(input())
for i in range(t):
	j = int(input())
	num = '11'
	for k in range(j):
		print(k + 2, end='')
		num += '1'
		if k < j - 1:
			print(' ', end='')
	print()


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
from collections import *
from bisect import *
from string import *
from itertools import *
from statistics import *
from math import *
from heapq import heappush as push, heappop as pop
from re import *
from functools import cmp_to_key
from queue import *
mod = int(1000000000.0 + 7)
mod1 = 998244353
imax = float('inf')
imin = float('-inf')
true = True
false = False
N = 10 ** 5
vowels = 'aeiou'
none = None
t3bit = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
inp = lambda : input()
I = lambda : int(inp())
M = lambda : map(int, inp().split())
MS = lambda : map(str, inp().split())
S = lambda : list(MS())
L = lambda : list(M())
test_case_run__ = false

def case():
	global test_case_run__
	test_case_run__ = true

def exit():
	raise SystemExit
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
case()

def main():
	n = I()
	for i in range(n):
		print(1000 + 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')

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

class maths:

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

	def prec(self, a):
		return '{0:.10f}'.format(a)

def IO():
	try:
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	except:
		pass
maths = maths()
IO()
if test_case_run__:
	for i in range(I()):
		main()
else:
	main()


n = int(input())
for i in range(n):
	x = int(input())
	s = 0
	last = 2
	p = 3
	while s != x:
		if p % last == 0:
			p += 1
		else:
			print(p, end=' ')
			s += 1
			last = p
			p += 1
	print()


from sys import stdin
input = stdin.readline

def answer():
	ans = []
	for i in range(2, n + 2):
		ans.append(i)
	return ans
for T in range(int(input())):
	n = int(input())
	print(*answer())


t = int(input())
for _ in range(t):
	l = ''
	n = int(input())
	if n == 1:
		print(1)
	else:
		for i in range(1, n + 1):
			l = l + str(i + 1) + ' '
		print(str(l))


for i in range(int(input())):
	a = int(input())
	print(*[3 + i for i in range(a)])


import collections
import sys
from collections import OrderedDict, Counter, defaultdict
import math
import bisect
from sys import stdin, stdout

def with_index():
	a = []
	i = 0
	for t in map(int, input().split()):
		a.append((t, i))
		i += 1
	return a

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

def in1():
	return int(input())

def take_input():
	return stdin.readline()

def display_arr(arr):
	stdout.write(' '.join(map(str, arr)) + '\n')

def display_num(num):
	stdout.write(str(num) + '\n')

def factorial(n):
	return n * factorial(n - 1) if n > 1 else 1

def percent(c, s):
	return c / s * 100

def l2d(a):
	d = {}
	for i in a:
		if i in d:
			d[i] += 1
		else:
			d[i] = 1
	return d

def min_op(a, n, count):
	if n == 1:
		return 0
	if count >= 2:
		return n - count // 2
	return -1

def Arr(n):
	if n == 1:
		return [1]
	if n == 2:
		return [2, 3]
	a = [2, 3]
	i = 4
	while len(a) != n:
		if i % a[-1] != 0:
			a.append(i)
		i += 1
	return a
for _ in range(in1()):
	n = in1()
	print(*Arr(n))


import sys
input = sys.stdin.readline

def get_int():
	return int(input().rstrip())

def get_arr():
	return [int(w) for w in input().split()]
t = get_int()
for _ in range(t):
	n = get_int()
	a = [2 * n + i for i in range(n)]
	print(*a)


from __future__ import division, print_function
import os
import sys
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

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

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()
from os import path
import bisect
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output1.txt', 'w')
from heapq import heappop, heappush, heapify
from math import ceil, log
from collections import defaultdict, deque, Counter
maxi = sys.maxsize
mini = -maxi
from os import path
import bisect, sys
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output1.txt', 'w')
from heapq import heappop, heappush, heapify
from math import ceil, log
from collections import defaultdict, deque, Counter
maxi = sys.maxsize
mini = -maxi
for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print(1)
	else:
		l = [i for i in range(2, n + 2)]
		print(*l)


t = int(input())
result = []
for i in range(t):
	n = int(input())
	res = []
	tmp = 1
	for j in range(n):
		tmp += 1
		res.append(tmp)
	result.append(res)
for x in result:
	print(*x, sep=' ')


for i in range(int(input())):
	arr = []
	a = int(input())
	arr.append(a)
	for i in range(a, a * 5):
		if i % a != 0:
			arr.append(i)
	print(*arr[:a])


inp1 = int(input())
for i in range(inp1):
	o = ''
	inp2 = int(input())
	if inp2 == 1:
		print(1)
	else:
		for j in range(2, inp2 + 2):
			o += str(j) + ' '
		print(o)


n = int(input())
arr = []
for i in range(n):
	m = int(input())
	num = m
	for i in range(m):
		print(num, end=' ')
		num += 1
	print()


t = int(input())
for i in range(t):
	n = int(input())
	if n == 1:
		print(1)
	elif n == 2:
		print('2 3')
	else:
		a = str(11)
		for i in range(1, n + 1):
			print(a + str(1 * i), end=' ')
		print()


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 _ in range(int(input())):
	n = int(input())
	start = 2
	a = []
	for i in range(n):
		a.append(start)
		start += 1
	print(*a)


for _ in range(int(input())):
	n = int(input())
	print(' '.join([str(i) for i in range(2, n + 2)]))


def ans():
	for _ in range(int(input())):
		n = int(input())
		for i in range(2, n + 2):
			print(i, end=' ')
		print()
ans()


for t in range(int(input())):
	n = int(input())
	A = [int(i) for i in range(2, n + 2)]
	print(*A)


t = int(input())
for i in range(t):
	x = int(input())
	a = 12
	for i in range(x):
		print(a, end=' ')
		a += 1
	print()


for _ in range(int(input())):
	n = int(input())
	l = []
	for i in range(n):
		l.append(2 + i)
	print(*l)


def Solve():
	n = int(input())
	print(2, end=' ')
	for i in range(1, n):
		print(i + 2, end=' ')
	print()
q = int(input())
while q > 0:
	Solve()
	q = q - 1


for _ in range(int(input())):
	n = int(input())
	o = ''
	if n == 1:
		print(1)
	else:
		for i in range(2, n + 2):
			o += str(i) + ' '
		print(o)


import sys
import pprint
import logging
from logging import getLogger

def input():
	return sys.stdin.readline().rstrip('\r\n')
logging.basicConfig(format='%(message)s', level=logging.WARNING)
logger = getLogger(__name__)
logger.setLevel(logging.INFO)

def debug(msg, *args):
	logger.info(f'{msg}={pprint.pformat(args)}')
for i in range(int(input())):
	n = int(input())
	a = []
	i = 2
	while len(a) < n:
		a.append(i)
		i += 1
	print(*a)


t = int(input())
for _ in range(t):
	n = int(input())
	arr = [2]
	if n == 1:
		print(*arr)
	else:
		dummy = 3
		for i in range(1, n):
			arr.append(dummy)
			dummy = dummy + 1
		print(*arr)


t = int(input())
for i in range(t):
	A = []
	n = int(input())
	m = 2
	for j in range(n):
		p = m + 1
		if p % m != 0:
			A.append(p)
		m = A[j]
	for e in A:
		print(e, end=' ')


k = int(input())
rr = []
for i in range(k):
	n = int(input())
	sieve = ['2', '3', '5', '7', '11', '13', '17', '19', '23', '29', '31', '37', '41', '43', '47', '53', '59', '61', '67', '71', '73', '79', '83', '89', '97', '101', '103', '107', '109', '113', '127', '131', '137', '139', '149', '151', '157', '163', '167', '173', '179', '181', '191', '193', '197', '199', '211', '223', '227', '229', '233', '239', '241', '251', '257', '263', '269', '271', '277', '281', '283', '293', '307', '311', '313', '317', '331', '337', '347', '349', '353', '359', '367', '373', '379', '383', '389', '397', '401', '409', '419', '421', '431', '433', '439', '443', '449', '457', '461', '463', '467', '479', '487', '491', '499', '503', '509', '521', '523', '541', '547', '557', '563', '569', '571', '577', '587', '593', '599', '601', '607', '613', '617', '619', '631', '641', '643', '647', '653', '659', '661', '673', '677', '683', '691', '701', '709', '719', '727', '733', '739', '743', '751', '757', '761', '769', '773', '787', '797', '809', '811', '821', '823', '827', '829', '839', '853', '857', '859', '863', '877', '881', '883', '887', '907', '911', '919', '929', '937', '941', '947', '953', '967', '971', '977', '983', '991', '997', '1009', '1013', '1019', '1021', '1031', '1033', '1039', '1049', '1051', '1061', '1063', '1069', '1087', '1091', '1093', '1097', '1103', '1109', '1117', '1123', '1129', '1151', '1153', '1163', '1171', '1181', '1187', '1193', '1201', '1213', '1217', '1223', '1229', '1231', '1237', '1249', '1259', '1277', '1279', '1283', '1289', '1291', '1297', '1301', '1303', '1307', '1319', '1321', '1327', '1361', '1367', '1373', '1381', '1399', '1409', '1423', '1427', '1429', '1433', '1439', '1447', '1451', '1453', '1459', '1471', '1481', '1483', '1487', '1489', '1493', '1499', '1511', '1523', '1531', '1543', '1549', '1553', '1559', '1567', '1571', '1579', '1583', '1597', '1601', '1607', '1609', '1613', '1619', '1621', '1627', '1637', '1657', '1663', '1667', '1669', '1693', '1697', '1699', '1709', '1721', '1723', '1733', '1741', '1747', '1753', '1759', '1777', '1783', '1787', '1789', '1801', '1811', '1823', '1831', '1847', '1861', '1867', '1871', '1873', '1877', '1879', '1889', '1901', '1907', '1913', '1931', '1933', '1949', '1951', '1973', '1979', '1987', '1993', '1997', '1999', '2003', '2011', '2017', '2027', '2029', '2039', '2053', '2063', '2069', '2081', '2083', '2087', '2089', '2099', '2111', '2113', '2129', '2131', '2137', '2141', '2143', '2153', '2161', '2179', '2203', '2207', '2213', '2221', '2237', '2239', '2243', '2251', '2267', '2269', '2273', '2281', '2287', '2293', '2297', '2309', '2311', '2333', '2339', '2341', '2347', '2351', '2357', '2371', '2377', '2381', '2383', '2389', '2393', '2399', '2411', '2417', '2423', '2437', '2441', '2447', '2459', '2467', '2473', '2477', '2503', '2521', '2531', '2539', '2543', '2549', '2551', '2557', '2579', '2591', '2593', '2609', '2617', '2621', '2633', '2647', '2657', '2659', '2663', '2671', '2677', '2683', '2687', '2689', '2693', '2699', '2707', '2711', '2713', '2719', '2729', '2731', '2741', '2749', '2753', '2767', '2777', '2789', '2791', '2797', '2801', '2803', '2819', '2833', '2837', '2843', '2851', '2857', '2861', '2879', '2887', '2897', '2903', '2909', '2917', '2927', '2939', '2953', '2957', '2963', '2969', '2971', '2999', '3001', '3011', '3019', '3023', '3037', '3041', '3049', '3061', '3067', '3079', '3083', '3089', '3109', '3119', '3121', '3137', '3163', '3167', '3169', '3181', '3187', '3191', '3203', '3209', '3217', '3221', '3229', '3251', '3253', '3257', '3259', '3271', '3299', '3301', '3307', '3313', '3319', '3323', '3329', '3331', '3343', '3347', '3359', '3361', '3371', '3373', '3389', '3391', '3407', '3413', '3433', '3449', '3457', '3461', '3463', '3467', '3469', '3491', '3499', '3511', '3517', '3527', '3529', '3533', '3539', '3541', '3547', '3557', '3559', '3571', '3581', '3583', '3593', '3607', '3613', '3617', '3623', '3631', '3637', '3643', '3659', '3671', '3673', '3677', '3691', '3697', '3701', '3709', '3719', '3727', '3733', '3739', '3761', '3767', '3769', '3779', '3793', '3797', '3803', '3821', '3823', '3833', '3847', '3851', '3853', '3863', '3877', '3881', '3889', '3907', '3911', '3917', '3919', '3923', '3929', '3931', '3943', '3947', '3967', '3989', '4001', '4003', '4007', '4013', '4019', '4021', '4027', '4049', '4051', '4057', '4073', '4079', '4091', '4093', '4099', '4111', '4127', '4129', '4133', '4139', '4153', '4157', '4159', '4177', '4201', '4211', '4217', '4219', '4229', '4231', '4241', '4243', '4253', '4259', '4261', '4271', '4273', '4283', '4289', '4297', '4327', '4337', '4339', '4349', '4357', '4363', '4373', '4391', '4397', '4409', '4421', '4423', '4441', '4447', '4451', '4457', '4463', '4481', '4483', '4493', '4507', '4513', '4517', '4519', '4523', '4547', '4549', '4561', '4567', '4583', '4591', '4597', '4603', '4621', '4637', '4639', '4643', '4649', '4651', '4657', '4663', '4673', '4679', '4691', '4703', '4721', '4723', '4729', '4733', '4751', '4759', '4783', '4787', '4789', '4793', '4799', '4801', '4813', '4817', '4831', '4861', '4871', '4877', '4889', '4903', '4909', '4919', '4931', '4933', '4937', '4943', '4951', '4957', '4967', '4969', '4973', '4987', '4993', '4999', '5003', '5009', '5011', '5021', '5023', '5039', '5051', '5059', '5077', '5081', '5087', '5099', '5101', '5107', '5113', '5119', '5147', '5153', '5167', '5171', '5179', '5189', '5197', '5209', '5227', '5231', '5233', '5237', '5261', '5273', '5279', '5281', '5297', '5303', '5309', '5323', '5333', '5347', '5351', '5381', '5387', '5393', '5399', '5407', '5413', '5417', '5419', '5431', '5437', '5441', '5443', '5449', '5471', '5477', '5479', '5483', '5501', '5503', '5507', '5519', '5521', '5527', '5531', '5557', '5563', '5569', '5573', '5581', '5591', '5623', '5639', '5641', '5647', '5651', '5653', '5657', '5659', '5669', '5683', '5689', '5693', '5701', '5711', '5717', '5737', '5741', '5743', '5749', '5779', '5783', '5791', '5801', '5807', '5813', '5821', '5827', '5839', '5843', '5849', '5851', '5857', '5861', '5867', '5869', '5879', '5881', '5897', '5903', '5923', '5927', '5939', '5953', '5981', '5987', '6007', '6011', '6029', '6037', '6043', '6047', '6053', '6067', '6073', '6079', '6089', '6091', '6101', '6113', '6121', '6131', '6133', '6143', '6151', '6163', '6173', '6197', '6199', '6203', '6211', '6217', '6221', '6229', '6247', '6257', '6263', '6269', '6271', '6277', '6287', '6299', '6301', '6311', '6317', '6323', '6329', '6337', '6343', '6353', '6359', '6361', '6367', '6373', '6379', '6389', '6397', '6421', '6427', '6449', '6451', '6469', '6473', '6481', '6491', '6521', '6529', '6547', '6551', '6553', '6563', '6569', '6571', '6577', '6581', '6599', '6607', '6619', '6637', '6653', '6659', '6661', '6673', '6679', '6689', '6691', '6701', '6703', '6709', '6719', '6733', '6737', '6761', '6763', '6779', '6781', '6791', '6793', '6803', '6823', '6827', '6829', '6833', '6841', '6857', '6863', '6869', '6871', '6883', '6899', '6907', '6911', '6917', '6947', '6949', '6959', '6961', '6967', '6971', '6977', '6983', '6991', '6997', '7001', '7013', '7019', '7027', '7039', '7043', '7057', '7069', '7079', '7103', '7109', '7121', '7127', '7129', '7151', '7159', '7177', '7187', '7193', '7207', '7211', '7213', '7219', '7229', '7237', '7243', '7247', '7253', '7283', '7297', '7307', '7309', '7321', '7331', '7333', '7349', '7351', '7369', '7393', '7411', '7417', '7433', '7451', '7457', '7459', '7477', '7481', '7487', '7489', '7499', '7507', '7517', '7523', '7529', '7537', '7541', '7547', '7549', '7559', '7561', '7573', '7577', '7583', '7589', '7591', '7603', '7607', '7621', '7639', '7643', '7649', '7669', '7673', '7681', '7687', '7691', '7699', '7703', '7717', '7723', '7727', '7741', '7753', '7757', '7759', '7789', '7793', '7817', '7823', '7829', '7841', '7853', '7867', '7873', '7877', '7879', '7883', '7901', '7907', '7919', '7927', '7933', '7937', '7949', '7951', '7963', '7993', '8009', '8011', '8017', '8039', '8053', '8059', '8069', '8081', '8087', '8089', '8093', '8101', '8111', '8117', '8123', '8147', '8161', '8167', '8171', '8179', '8191', '8209', '8219', '8221', '8231', '8233', '8237', '8243', '8263', '8269', '8273', '8287', '8291', '8293', '8297', '8311', '8317', '8329', '8353', '8363', '8369', '8377', '8387', '8389', '8419', '8423', '8429', '8431', '8443', '8447', '8461', '8467', '8501', '8513', '8521', '8527', '8537', '8539', '8543', '8563', '8573', '8581', '8597', '8599', '8609', '8623', '8627', '8629', '8641', '8647', '8663', '8669', '8677', '8681', '8689', '8693', '8699', '8707', '8713', '8719', '8731', '8737', '8741', '8747', '8753', '8761', '8779', '8783', '8803', '8807', '8819', '8821', '8831', '8837', '8839', '8849', '8861', '8863', '8867', '8887', '8893', '8923', '8929', '8933', '8941', '8951', '8963', '8969', '8971', '8999', '9001', '9007', '9011', '9013', '9029', '9041', '9043', '9049', '9059', '9067', '9091', '9103', '9109', '9127', '9133', '9137', '9151', '9157', '9161', '9173', '9181', '9187', '9199', '9203', '9209', '9221', '9227', '9239', '9241', '9257', '9277', '9281', '9283', '9293', '9311', '9319', '9323', '9337', '9341', '9343', '9349', '9371', '9377', '9391', '9397', '9403', '9413', '9419', '9421', '9431', '9433', '9437', '9439', '9461', '9463', '9467', '9473', '9479', '9491', '9497', '9511', '9521', '9533', '9539', '9547', '9551', '9587', '9601', '9613', '9619', '9623', '9629', '9631', '9643', '9649', '9661', '9677', '9679', '9689', '9697', '9719', '9721', '9733', '9739', '9743', '9749', '9767', '9769', '9781', '9787', '9791', '9803', '9811', '9817', '9829', '9833', '9839', '9851', '9857', '9859', '9871', '9883', '9887', '9901', '9907', '9923', '9929', '9931', '9941', '9949', '9967', '9973', '10007', '10009', '10037', '10039', '10061', '10067', '10069', '10079', '10091', '10093', '10099', '10103', '10111', '10133', '10139', '10141', '10151', '10159', '10163', '10169', '10177', '10181', '10193', '10211', '10223', '10243', '10247', '10253', '10259', '10267', '10271', '10273', '10289', '10301', '10303', '10313', '10321', '10331', '10333', '10337', '10343', '10357', '10369', '10391', '10399', '10427', '10429', '10433', '10453', '10457', '10459', '10463', '10477', '10487', '10499', '10501', '10513', '10529', '10531', '10559', '10567', '10589', '10597', '10601', '10607', '10613', '10627', '10631', '10639', '10651', '10657', '10663', '10667', '10687', '10691', '10709', '10711', '10723', '10729', '10733', '10739', '10753', '10771', '10781', '10789', '10799', '10831', '10837', '10847', '10853', '10859', '10861', '10867', '10883', '10889', '10891', '10903', '10909', '10937', '10939', '10949', '10957', '10973', '10979', '10987', '10993']
	lst = []
	rr.append(' '.join(sieve[:n]))
print('\n'.join(rr))


def main():
	t = int(input())
	for i in range(t):
		n = int(input())
		nums = [5]
		if n > 1:
			for j in range(n - 1):
				nums.append(nums[-1] + 1)
		nums = [str(i) for i in nums]
		print(' '.join(nums))
main()


from sys import stdin, stdout, setrecursionlimit
from io import BytesIO, IOBase
from math import gcd, floor, sqrt, ceil
setrecursionlimit(10000)

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		import os
		self.os = os
		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
		self.BUFSIZE = 8192

	def read(self):
		while True:
			a = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.BUFSIZE))
			if not a:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(a), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			a = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.BUFSIZE))
			self.newlines = a.count(b'\n') + (not a)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(a), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			self.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')
(stdin, stdout) = (IOWrapper(stdin), IOWrapper(stdout))
input = lambda : stdin.readline().rstrip('\r\n')
inp = lambda : int(input())
st = lambda : input().strip()
jn = lambda x, l: x.join(map(str, l))
int_arr = lambda : list(map(int, input().strip().split()))
str_arr = lambda : list(map(str, input().split()))
get_str = lambda : map(str, input().strip().split())
get_int = lambda : map(int, input().strip().split())
get_float = lambda : map(float, input().strip().split())
mod = 1000000007
for _ in range(inp()):
	n = inp()
	lst = [i for i in range(2, n + 2)]
	print(*lst)


for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print(1)
	else:
		l = []
		for i in range(2, n + 2):
			l.append(i)
		print(*l)


t = int(input())
for i in range(t):
	n = int(input('\n'))
	i = 1
	while i <= n:
		print(2 * i + 1, end=' ')
		i = i + 1


bramaresh = int(input())
for i in range(bramaresh):
	klh = int(input())
	l = []
	j = 2
	for k in range(klh):
		l.append(j)
		j = j + 1
	for f in l:
		print(f, end=' ')
	print()


for _ in range(int(input())):
	n = int(input())
	arr = [i for i in range(n, n + n)]
	for i in arr:
		print(i, end=' ')
	print()


for i in range(int(input())):
	res = []
	n = int(input())
	if n == 1:
		res.append(1)
	else:
		for i in range(2, n + 2):
			res.append(i)
		for i in range(1, len(res)):
			while res[i] % res[i - 1] == 0:
				res[i] += 1
	print(*res)


for i in range(int(input())):
	n = int(input())
	a = []
	for j in range(2, n + 2):
		a.append(j)
	print(*a)


t = int(input())
for i in range(t):
	n = int(input())
	l = []
	i = 2
	while i < n + 2:
		l.append(i)
		i += 1
	print(*l)


def solve():
	n = int(input())
	for i in range(2, n + 2):
		print(i, end=' ')
	print()
t = int(input())
while t != 0:
	solve()
	t -= 1


t = int(input())
while t > 0:
	t = t - 1
	n = int(input())
	b = [2]
	x = 3
	for i in range(n - 1):
		b.append(x)
		x += 1
	print(*b)


from collections import deque as de
import math
import sys
from math import sqrt as sq
from math import floor as fl
from math import ceil as ce
from sys import stdin, stdout
import time
sys.setrecursionlimit(10 ** 7)
from collections import Counter as cnt
from functools import reduce
from itertools import groupby as gb
from bisect import bisect_left as bl, bisect_right as br
from typing import Coroutine

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

class My_stack:

	def __init__(self):
		self.data = []

	def my_push(self, x):
		return self.data.append(x)

	def my_pop(self):
		return self.data.pop()

	def __iter__(self):
		return iter(self.data)

	def my_peak(self):
		return self.data[-1]

	def my_contains(self, x):
		return self.data.count(x)

	def my_show_all(self):
		return self.data

	def isEmpty(self):
		return len(self.data) == 0

	def len(self):
		return len(self.data)
arrStack = My_stack()

class graph:

	def __init__(self):
		self.graphdict = {}

	def add_edge(self, node, neighbor):
		if node not in self.graphdict:
			self.graphdict[node] = [neighbor]
		else:
			self.graphdict[node].append(neighbor)

	def show_edge(self):
		for node in self.graphdict:
			for neighbors in self.graphdict:
				print(node, neighbors)

	def show_graph(self):
		return self.graphdict

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def binarytodecimal(n):
	return int(n, 2)

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 get_prime_factors(number):
	prime_factors = []
	while number % 2 == 0:
		prime_factors.append(2)
		number = number / 2
	for i in range(3, int(math.sqrt(number)) + 1, 2):
		while number % i == 0:
			prime_factors.append(int(i))
			number = number / i
	if number > 2:
		prime_factors.append(int(number))
	return prime_factors

def get_frequency(list):
	dic = {}
	for ele in list:
		if ele in dic:
			dic[ele] += 1
		else:
			dic[ele] = 1
	return dic

def Log2(x):
	return math.log10(x) / math.log10(2)

def getProduct(n):
	product = 1
	while n != 0:
		product = product * (n % 10)
		n = n // 10
	return product

def regularBracketsequence(str, arrStack):
	for i in range(len(str)):
		if str[i] == '(':
			arrStack.my_push(str[i])
		elif arrStack.isEmpty():
			return False
		else:
			arrStack.my_pop()
	if arrStack.isEmpty():
		return True
	else:
		return False

def lcm(x, y):
	lcm = x * y // math.gcd(x, y)
	return lcm

def isPowerOfTwo(n):
	return math.ceil(Log2(n)) == math.floor(Log2(n))

def checkisap(list):
	d = list[1] - list[0]
	for i in range(2, len(list)):
		temp = list[i] - list[i - 1]
		if temp != d:
			return False
	return True

def primes_method5(n):
	out = {}
	sieve = [True] * (n + 1)
	for p in range(2, n + 1):
		if sieve[p]:
			out[p] = 1
			for i in range(p, n + 1, p):
				sieve[i] = False
	return out

def id(i, j, col):
	ans = (i - 1) * col
	ans += j
	return ans

def getSum(n):
	strr = str(n)
	list_of_number = list(map(int, strr.strip()))
	return sum(list_of_number)

def checkperfectsquare(n):
	if ce(sq(n)) == fl(sq(n)):
		return True
	else:
		return False

def combinatrics(n, r):
	num = n
	deno = n - r
	pr = 1
	for i in range(num, deno, -1):
		pr *= i
	an = 1
	for i in range(1, r + 1):
		an *= i
	ans = pr // an
	return ans

def ceildiv(x, y):
	return (x + y - 1) // y

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

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

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

def si():
	return list(map(str, input()))

def indict():
	dic = {}
	for (index, value) in enumerate(input().split()):
		dic[int(value)] = int(index)
	return dic

def frqdict():
	dic = {}
	for (index, value) in enumerate(input()):
		if value not in dic:
			dic[value] = 1
		else:
			dic[value] += 1
	return dic
t = ii()
while t:
	t -= 1
	n = ii()
	for i in range(2, n + 2):
		print(i, end=' ')


for _ in range(int(input())):
	i = int(input()) - 1
	t = [3]
	for x in range(i):
		t.append((x + 2) * 2)
	print(*t)


for _ in range(int(input())):
	n = int(input())
	arr = []
	for i in range(2, n + 2):
		arr.append(i)
	print(' '.join((str(x) for x in arr)))


from bisect import insort, bisect_right, bisect_left
from sys import stdout, stdin, setrecursionlimit
from heapq import heappush, heappop, heapify
from io import BytesIO, IOBase
from collections import *
from itertools import *
from random import *
from string import *
from queue import *
from math import *
from re import *
from os import *

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, 8192))
			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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
			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')
(stdin, stdout) = (IOWrapper(stdin), IOWrapper(stdout))
(graph, mod, szzz) = ({}, 10 ** 9 + 7, lambda : sorted(zzz()))

def getStr():
	return input()

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

def listStr():
	return list(input())

def getStrs():
	return input().split()

def isInt(s):
	return '0' <= s[0] <= '9'

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

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

def output(answer, end='\n'):
	stdout.write(str(answer) + end)

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

def getPrimes(N=10 ** 5):
	SN = int(sqrt(N))
	sieve = [i for i in range(N + 1)]
	sieve[1] = 0
	for i in sieve:
		if i > SN:
			break
		if i == 0:
			continue
		for j in range(2 * i, N + 1, i):
			sieve[j] = 0
	prime = [i for i in range(N + 1) if sieve[i] != 0]
	return prime

def primeFactor(n, prime=getPrimes()):
	lst = []
	mx = int(sqrt(n)) + 1
	for i in prime:
		if i > mx:
			break
		while n % i == 0:
			lst.append(i)
			n //= i
	if n > 1:
		lst.append(n)
	return lst
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
daysInMounth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
num = getInt()
for _ in range(num):
	n = getInt()
	print(*list(range(2, n + 2)))


import sys, os, io
import math
from collections import defaultdict

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

def li():
	return list(map(int, input().split()))
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def solve():
	n = ii()
	l = [i for i in range(2, n + 2)]
	print(*l)
t = 1
t = ii()
for _ in range(t):
	solve()


from sys import stdin

def solve():
	for _ in range(int(stdin.readline().strip())):
		n = int(stdin.readline().rstrip())
		A = list(range(2, n + 2))
		print(' '.join(map(str, A)))
solve()


import os
import sys
import math
from io import BytesIO, IOBase
import io
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
from collections import Counter
import threading
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')

class SegmentTree:

	def __init__(self, data, default=10 ** 18, func=lambda a, b: min(a, b)):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class SegmentTree1:

	def __init__(self, data, default=0, func=lambda a, b: a + b):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)
MOD = 10 ** 9 + 7

class Factorial:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorials = [1, 1]
		self.invModulos = [0, 1]
		self.invFactorial_ = [1, 1]

	def calc(self, n):
		if n <= -1:
			print('Invalid argument to calculate n!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.factorials):
			return self.factorials[n]
		nextArr = [0] * (n + 1 - len(self.factorials))
		initialI = len(self.factorials)
		prev = self.factorials[-1]
		m = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * i % m
		self.factorials += nextArr
		return self.factorials[n]

	def inv(self, n):
		if n <= -1:
			print('Invalid argument to calculate n^(-1)')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		p = self.MOD
		pi = n % p
		if pi < len(self.invModulos):
			return self.invModulos[pi]
		nextArr = [0] * (n + 1 - len(self.invModulos))
		initialI = len(self.invModulos)
		for i in range(initialI, min(p, n + 1)):
			next = -self.invModulos[p % i] * (p // i) % p
			self.invModulos.append(next)
		return self.invModulos[pi]

	def invFactorial(self, n):
		if n <= -1:
			print('Invalid argument to calculate (n^(-1))!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.invFactorial_):
			return self.invFactorial_[n]
		self.inv(n)
		nextArr = [0] * (n + 1 - len(self.invFactorial_))
		initialI = len(self.invFactorial_)
		prev = self.invFactorial_[-1]
		p = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * self.invModulos[i % p] % p
		self.invFactorial_ += nextArr
		return self.invFactorial_[n]

class Combination:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorial = Factorial(MOD)

	def ncr(self, n, k):
		if k < 0 or n < k:
			return 0
		k = min(k, n - k)
		f = self.factorial
		return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod = 10 ** 9 + 7
omod = 998244353
prime = [True for i in range(10001)]
prime[0] = prime[1] = False

def SieveOfEratosthenes(n=10000):
	p = 2
	c = 0
	while p <= n:
		if prime[p] == True:
			c += 1
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1

class DSU:

	def __init__(self, R, C):
		self.par = range(R * C + 1)
		self.rnk = [0] * (R * C + 1)
		self.sz = [1] * (R * C + 1)

	def find(self, x):
		if self.par[x] != x:
			self.par[x] = self.find(self.par[x])
		return self.par[x]

	def union(self, x, y):
		(xr, yr) = (self.find(x), self.find(y))
		if xr == yr:
			return
		if self.rnk[xr] < self.rnk[yr]:
			(xr, yr) = (yr, xr)
		if self.rnk[xr] == self.rnk[yr]:
			self.rnk[xr] += 1
		self.par[yr] = xr
		self.sz[xr] += self.sz[yr]

	def size(self, x):
		return self.sz[self.find(x)]

	def top(self):
		return self.size(len(self.sz) - 1) - 1

class LazySegTree:

	def __init__(self, _op, _e, _mapping, _composition, _id, v):

		def set(p, x):
			assert 0 <= p < _n
			p += _size
			for i in range(_log, 0, -1):
				_push(p >> i)
			_d[p] = x
			for i in range(1, _log + 1):
				_update(p >> i)

		def get(p):
			assert 0 <= p < _n
			p += _size
			for i in range(_log, 0, -1):
				_push(p >> i)
			return _d[p]

		def prod(l, r):
			assert 0 <= l <= r <= _n
			if l == r:
				return _e
			l += _size
			r += _size
			for i in range(_log, 0, -1):
				if l >> i << i != l:
					_push(l >> i)
				if r >> i << i != r:
					_push(r >> i)
			sml = _e
			smr = _e
			while l < r:
				if l & 1:
					sml = _op(sml, _d[l])
					l += 1
				if r & 1:
					r -= 1
					smr = _op(_d[r], smr)
				l >>= 1
				r >>= 1
			return _op(sml, smr)

		def apply(l, r, f):
			assert 0 <= l <= r <= _n
			if l == r:
				return
			l += _size
			r += _size
			for i in range(_log, 0, -1):
				if l >> i << i != l:
					_push(l >> i)
				if r >> i << i != r:
					_push(r - 1 >> i)
			l2 = l
			r2 = r
			while l < r:
				if l & 1:
					_all_apply(l, f)
					l += 1
				if r & 1:
					r -= 1
					_all_apply(r, f)
				l >>= 1
				r >>= 1
			l = l2
			r = r2
			for i in range(1, _log + 1):
				if l >> i << i != l:
					_update(l >> i)
				if r >> i << i != r:
					_update(r - 1 >> i)

		def _update(k):
			_d[k] = _op(_d[2 * k], _d[2 * k + 1])

		def _all_apply(k, f):
			_d[k] = _mapping(f, _d[k])
			if k < _size:
				_lz[k] = _composition(f, _lz[k])

		def _push(k):
			_all_apply(2 * k, _lz[k])
			_all_apply(2 * k + 1, _lz[k])
			_lz[k] = _id
		_n = len(v)
		_log = _n.bit_length()
		_size = 1 << _log
		_d = [_e] * (2 * _size)
		_lz = [_id] * _size
		for i in range(_n):
			_d[_size + i] = v[i]
		for i in range(_size - 1, 0, -1):
			_update(i)
		self.set = set
		self.get = get
		self.prod = prod
		self.apply = apply
MIL = 1 << 20

def makeNode(total, count):
	return total * MIL + count

def getTotal(node):
	return math.floor(node / MIL)

def getCount(node):
	return node - getTotal(node) * MIL
nodeIdentity = makeNode(0.0, 0.0)

def nodeOp(node1, node2):
	return node1 + node2
	return makeNode(getTotal(node1) + getTotal(node2), getCount(node1) + getCount(node2))
identityMapping = -1

def mapping(tag, node):
	if tag == identityMapping:
		return node
	count = getCount(node)
	return makeNode(tag * count, count)

def composition(mapping1, mapping2):
	return mapping1 if mapping1 != identityMapping else mapping2

class LazySegUpdate:

	def __init__(self, N):
		self.N = N
		n = 4 * N
		self.tree = [0] * n
		self.lazy = [0] * n

	def queryHelper(self, index, s, e, l, r):
		if self.lazy[index]:
			update = self.lazy[index]
			self.lazy[index] = 0
			self.tree[index] = max(self.tree[index], update)
			if s != e:
				self.lazy[2 * index] = max(self.lazy[2 * index], update)
				self.lazy[2 * index + 1] = max(self.lazy[2 * index + 1], update)
		if s > e or s > r or e < l:
			return 0
		if s >= l and e <= r:
			return self.tree[index]
		mid = (s + e) // 2
		return max(self.queryHelper(2 * index, s, mid, l, r), self.queryHelper(2 * index + 1, mid + 1, e, l, r))

	def updateHelper(self, index, s, e, l, r, h):
		if self.lazy[index]:
			update = self.lazy[index]
			self.lazy[index] = 0
			self.tree[index] = max(self.tree[index], update)
			if s != e:
				self.lazy[2 * index] = max(self.lazy[2 * index], update)
				self.lazy[2 * index + 1] = max(self.lazy[2 * index + 1], update)
		if s > e or s > r or e < l:
			return
		if s >= l and e <= r:
			self.tree[index] = max(self.tree[index], h)
			if s != e:
				self.lazy[2 * index] = max(self.lazy[2 * index], h)
				self.lazy[2 * index + 1] = max(self.lazy[2 * index + 1], h)
			return
		mid = (s + e) // 2
		self.updateHelper(2 * index, s, mid, l, r, h)
		self.updateHelper(2 * index + 1, mid + 1, e, l, r, h)
		self.tree[index] = max(self.tree[2 * index], self.tree[2 * index + 1])

	def query(self, l, r):
		return self.queryHelper(1, 0, self.N - 1, l, r - 1)

	def update(self, l, r, h):
		self.updateHelper(1, 0, self.N - 1, l, r - 1, h)

def memodict(f):

	class memodict(dict):

		def __missing__(self, key):
			ret = self[key] = f(key)
			return ret
	return memodict().__getitem__

def pollard_rho(n):
	if n & 1 == 0:
		return 2
	if n % 3 == 0:
		return 3
	s = (n - 1 & 1 - n).bit_length() - 1
	d = n >> s
	for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
		p = pow(a, d, n)
		if p == 1 or p == n - 1 or a % n == 0:
			continue
		for _ in range(s):
			prev = p
			p = p * p % n
			if p == 1:
				return math.gcd(prev - 1, n)
			if p == n - 1:
				break
		else:
			for i in range(2, n):
				(x, y) = (i, (i * i + 1) % n)
				f = math.gcd(abs(x - y), n)
				while f == 1:
					(x, y) = ((x * x + 1) % n, (y * y + 1) % n)
					y = (y * y + 1) % n
					f = math.gcd(abs(x - y), n)
				if f != n:
					return f
	return n

@memodict
def prime_factors(n):
	if n <= 1:
		return Counter()
	f = pollard_rho(n)
	return Counter([n]) if f == n else prime_factors(f) + prime_factors(n // f)

def distinct_factors(n):
	factors = [1]
	for (p, exp) in prime_factors(n).items():
		factors += [p ** i * factor for factor in factors for i in range(1, exp + 1)]
	return factors

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

class SortedList:

	def __init__(self, iterable=[], _load=200):
		values = sorted(iterable)
		self._len = _len = len(values)
		self._load = _load
		self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
		self._list_lens = [len(_list) for _list in _lists]
		self._mins = [_list[0] for _list in _lists]
		self._fen_tree = []
		self._rebuild = True

	def _fen_build(self):
		self._fen_tree[:] = self._list_lens
		_fen_tree = self._fen_tree
		for i in range(len(_fen_tree)):
			if i | i + 1 < len(_fen_tree):
				_fen_tree[i | i + 1] += _fen_tree[i]
		self._rebuild = False

	def _fen_update(self, index, value):
		if not self._rebuild:
			_fen_tree = self._fen_tree
			while index < len(_fen_tree):
				_fen_tree[index] += value
				index |= index + 1

	def _fen_query(self, end):
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		x = 0
		while end:
			x += _fen_tree[end - 1]
			end &= end - 1
		return x

	def _fen_findkth(self, k):
		_list_lens = self._list_lens
		if k < _list_lens[0]:
			return (0, k)
		if k >= self._len - _list_lens[-1]:
			return (len(_list_lens) - 1, k + _list_lens[-1] - self._len)
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		idx = -1
		for d in reversed(range(len(_fen_tree).bit_length())):
			right_idx = idx + (1 << d)
			if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
				idx = right_idx
				k -= _fen_tree[idx]
		return (idx + 1, k)

	def _delete(self, pos, idx):
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len -= 1
		self._fen_update(pos, -1)
		del _lists[pos][idx]
		_list_lens[pos] -= 1
		if _list_lens[pos]:
			_mins[pos] = _lists[pos][0]
		else:
			del _lists[pos]
			del _list_lens[pos]
			del _mins[pos]
			self._rebuild = True

	def _loc_left(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(lo, pos) = (-1, len(_lists) - 1)
		while lo + 1 < pos:
			mi = lo + pos >> 1
			if value <= _mins[mi]:
				pos = mi
			else:
				lo = mi
		if pos and value <= _lists[pos - 1][-1]:
			pos -= 1
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value <= _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def _loc_right(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(pos, hi) = (0, len(_lists))
		while pos + 1 < hi:
			mi = pos + hi >> 1
			if value < _mins[mi]:
				hi = mi
			else:
				pos = mi
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value < _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def add(self, value):
		_load = self._load
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len += 1
		if _lists:
			(pos, idx) = self._loc_right(value)
			self._fen_update(pos, 1)
			_list = _lists[pos]
			_list.insert(idx, value)
			_list_lens[pos] += 1
			_mins[pos] = _list[0]
			if _load + _load < len(_list):
				_lists.insert(pos + 1, _list[_load:])
				_list_lens.insert(pos + 1, len(_list) - _load)
				_mins.insert(pos + 1, _list[_load])
				_list_lens[pos] = _load
				del _list[_load:]
				self._rebuild = True
		else:
			_lists.append([value])
			_mins.append(value)
			_list_lens.append(1)
			self._rebuild = True

	def discard(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_right(value)
			if idx and _lists[pos][idx - 1] == value:
				self._delete(pos, idx - 1)

	def remove(self, value):
		_len = self._len
		self.discard(value)
		if _len == self._len:
			raise ValueError('{0!r} not in list'.format(value))

	def pop(self, index=-1):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		value = self._lists[pos][idx]
		self._delete(pos, idx)
		return value

	def bisect_left(self, value):
		(pos, idx) = self._loc_left(value)
		return self._fen_query(pos) + idx

	def bisect_right(self, value):
		(pos, idx) = self._loc_right(value)
		return self._fen_query(pos) + idx

	def count(self, value):
		return self.bisect_right(value) - self.bisect_left(value)

	def __len__(self):
		return self._len

	def __getitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		return self._lists[pos][idx]

	def __delitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		self._delete(pos, idx)

	def __contains__(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_left(value)
			return idx < len(_lists[pos]) and _lists[pos][idx] == value
		return False

	def __iter__(self):
		return (value for _list in self._lists for value in _list)

	def __reversed__(self):
		return (value for _list in reversed(self._lists) for value in reversed(_list))

	def __repr__(self):
		return 'SortedList({0})'.format(list(self))

def binarySearch(arr, n, key):
	left = 0
	right = n - 1
	mid = 0
	res = n
	while left <= right:
		mid = (right + left) // 2
		if arr[mid] >= key:
			res = mid
			right = mid - 1
		else:
			left = mid + 1
	return res

def binarySearch1(arr, n, key):
	left = 0
	right = n - 1
	mid = 0
	res = -1
	while left <= right:
		mid = (right + left) // 2
		if arr[mid] > key:
			right = mid - 1
		else:
			res = mid
			left = mid + 1
	return res
tt = 1
tt = int(input())
for _ in range(tt):
	n = int(input())
	a = [i + 2 for i in range(n)]
	print(*a)


t = int(input())
for i in range(t):
	n = int(input())
	l = [i for i in range(2, 2 + n)]
	for j in l:
		if j == l[-1]:
			print(j)
		else:
			print(j, end=' ')


for n in [*open(0)][1:]:
	print(*range(2, int(n) + 2))


import sys
from bisect import bisect_left as lb
from bisect import bisect_right as rb
from collections import deque
from queue import PriorityQueue as pq
from math import gcd
input_ = lambda : sys.stdin.readline().strip('\r\n')
ii = lambda : int(input_())
il = lambda : list(map(int, input_().split()))
ilf = lambda : list(map(float, input_().split()))
lii = lambda : list(map(int, list(ip())))
ip = lambda : input_()
fi = lambda : float(input_())
ap = lambda ab, bc, cd: ab[bc].append(cd)
li = lambda : list(input_())
pr = lambda x: print(x)
prinT = lambda x: print(x)
f = lambda : sys.stdout.flush()
inv = lambda x: pow(x, mod - 2, mod)
dx = [0, 0, 1, -1]
dy = [1, -1, 0, 0]
mod = 10 ** 9 + 7
mod1 = 998244353
for _ in range(ii()):
	n = ii()
	ans = [2 + i for i in range(n)]
	print(*ans)


t = int(input())
for _ in range(t):
	n = int(input())
	m = []
	for i in range(2, n + 2):
		m.append(i)
	print(*m)


from sys import stdout, stdin
from io import IOBase, BytesIO
from os import read, supports_follow_symlinks, 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))

def input():
	return stdin.readline().rstrip('\r\n')
BEGIN_NUMBER = 10

def main():
	t = int(input())
	for _ in ' ' * t:
		n = int(input())
		answer = list(range(BEGIN_NUMBER, BEGIN_NUMBER + n))
		print(*answer)
main()


def inp():
	return int(input())
t = inp()
for i in range(t):
	n = inp()
	lst = [2]
	for i in range(3, n + 2):
		lst.append(i)
	print(*lst)


t = int(input())
for i in range(t):
	n = int(input())
	print(' '.join([str(i) for i in list(range(2, n + 2))]))


n = int(input())
for i in range(n):
	t = int(input())
	arr = []
	if t == 1:
		print(1)
	else:
		for i in range(t):
			print(i + 2, end=' ')
		print(end='\n')


import math
t = int(input())
for i in range(t):
	n = int(input())
	lst = [i + 1 for i in range(1, n + 1)]
	print(*lst)