Iahub and Iahubina went to a date at a luxury restaurant. Everything went fine until paying for the food. Instead of money, the waiter wants Iahub to write a Hungry sequence consisting of n integers. 

A sequence a1, a2, ..., an, consisting of n integers, is Hungry if and only if: 

  * Its elements are in increasing order. That is an inequality ai < aj holds for any two indices i, j (i < j). 
  * For any two indices i and j (i < j), aj must not be divisible by ai. 



Iahub is in trouble, so he asks you for help. Find a Hungry sequence with n elements.

Input

The input contains a single integer: n (1 ≤ n ≤ 105).

Output

Output a line that contains n space-separated integers a1 a2, ..., an (1 ≤ ai ≤ 107), representing a possible Hungry sequence. Note, that each ai must not be greater than 10000000 (107) and less than 1.

If there are multiple solutions you can output any one.

Examples

Input

3


Output

2 9 15


Input

5


Output

11 14 20 27 31

Difficulty: EASY
Tags: Mathematics

Starter code:

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


n = int(input())
z = 10000000
for i in range(n, 0, -1):
	print(z - i, end=' ')


import sys
n = int(input())
for i in range(10000000 - n, 9999999):
	sys.stdout.write(str(i) + ' ')
sys.stdout.write('9999999')


def main():
	N = int(input())
	for i in range(N):
		print(3 * N + i, end=' ')
main()


n = int(input())
ans = []
n3 = n * 3
for i in range(n):
	ans += [str(n3 + i)]
print(' '.join(ans))


def SieveOfEratosthenes(n):
	n = max(n, 2)
	primes = [True for i in range(n + 1)]
	(primes[0], primes[1]) = (False, False)
	ct = 0
	while ct ** 2 <= n:
		if primes[ct]:
			for i in range(ct ** 2, n + 1, ct):
				primes[i] = False
		ct += 1
	return primes
lst = SieveOfEratosthenes(1500000)
ct = 0
i = 0
n = int(input())
while ct != n:
	if lst[i]:
		print(i, end=' ')
		ct += 1
	i += 1


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


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

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

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

def I():
	return int(stdin.readline())
P = 1000000007
n = I()
for i in range(n):
	print(3 * n + i, end=' ')


n = int(input())
ans = [i for i in range(n, 2 * n)]
print(*ans)


import sys, threading, os.path
import string
import collections, heapq, math, bisect, operator
sys.setrecursionlimit(10 ** 6)
threading.stack_size(2 ** 27)

def generate_primes(n):
	res = []
	isPrime = [True] * (n * 5)
	(isPrime[0], isPrime[1]) = (0, 0)
	for i in range(2, n + 1):
		if i * i > n + 1:
			break
		if isPrime[i]:
			for j in range(i * 2, n + 1, i):
				isPrime[j] = 0
	res.append(2)
	for i in range(3, n + 1, 2):
		if isPrime[i]:
			res.append(i)
	return res

def main():
	if os.path.exists('in.txt'):
		input = open('in.txt', 'r')
	else:
		input = sys.stdin
	n = int(input.readline())
	lis = generate_primes(1400000)
	output = ' '.join(map(str, lis[:n]))
	if os.path.exists('out.txt'):
		open('out.txt', 'w').writelines(str(output))
	else:
		sys.stdout.write(str(output))
main()


from math import sqrt, ceil
n = int(input())
print(' '.join(map(str, range(100000, 100000 + n))))


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


n = int(input())
print(' '.join((str(x) for x in range(n, 2 * n))))


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


n = int(input())
a = [k for k in range(n, 2 * n)]
for s in a:
	print(s, end=' ')


import sys
input = sys.stdin.readline

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

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

def primefs(n):
	primes = {}
	while n % 2 == 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	while x != link[x]:
		x = link[x]
	return x

def union(x, y, size, link):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(1000000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

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

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
n = int(input())
sieve = sieve(1300000)
ans = []
for i in range(2, len(sieve)):
	if sieve[i] == True:
		ans.append(i)
	if len(ans) == n:
		break
print(*ans)


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


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

class CodeforcesTask327BSolution:

	def __init__(self):
		self.result = ''
		self.n = 0

	def read_input(self):
		self.n = int(input())

	def process_task(self):
		print(' '.join([str(x) for x in SieveOfEratosthenes(1500000)][:self.n]))

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


n = int(input())
print(' '.join((str(i) for i in range(n, n + n))))


def print_first_N_primes(n):
	start = 9000001
	temp = start
	for i in range(start, start + n):
		print(i, end=' ')
num = int(input())
print_first_N_primes(num)
print('')


n = 1000001
t = [1] * n
p = 2
while p ** 2 <= n:
	if t[p] == 1:
		for j in range(p * 2, n, p):
			t[j] = 0
	p += 1
t[0] = 0
t[1] = 0
s = int(input())
u = []
for j in range(s):
	u.append(3 * s + j)
print(*u)


def main():
	n = int(input())
	l = list(range(n + 1, 2 * n + 1))
	print(*l)
main()


n = int(input())
l = []
for i in range(n):
	l.append(100001 + 1 + i)
print(' '.join(map(str, l)))


n = int(input())
(m, A) = (n, [])
for i in range(n):
	A.append(m)
	m += 1
answer = str(A[0])
for i in A[1:]:
	answer += ' ' + str(i)
print(answer)


n = int(input())
if n == 1:
	print(1)
else:
	print(2, 3, end=' ')
	n -= 2
	for i in range(5, 10000001, 2):
		if n == 0:
			break
		if i % 3 != 0:
			f = 1
			c = 5
			while c * c <= i:
				if i % c == 0 or i % (c + 2) == 0:
					f = 0
					break
				c += 6
			if f:
				print(i, end=' ')
				n -= 1


n = int(input())
a = [str(n) for n in range(n, 2 * n)]
print(' '.join(a))


n = int(input())
print(*list(range(n + 1, 2 * n + 1)), sep=' ')


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

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

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

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

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

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

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

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

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

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

def main():
	n = ii()
	cnt = 0
	ans = []
	i = n * 2
	while cnt < n:
		ans.append(i + cnt)
		cnt += 1
	print(*ans)
main()


def main(n):
	data = []
	k = 0
	while k != n:
		data.append(3 * n + k)
		k += 1
	print(*data)
n = int(input())
main(n)


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


mod = 10 ** 9 + 7

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

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

def readStringList():
	return list(input())

def readStringListWithSpace():
	return list(input().split())

def readString():
	return input()

def execute():
	n = readInt()
	for i in range(10000000 - n, 10000000):
		print(i, end=' ')
execute()


a = int(input())
for i in range(a):
	print(10 ** 6 + i, end=' ')


MAXN = 10 ** 6
n = int(input())
A = []
for x in range(1, n + 1):
	A.append(MAXN + x)
print(*A)


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


x = int(input())
for i in range(x):
	print(i + 700000, end=' ')


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


import sys
n = int(input())
ans = ''
for i in range(n):
	ans += str(3 * n + i)
	ans += ' '
print(ans)


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


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


n = int(input())
l = [i for i in range(100000, 100000 + n)]
print(*l)


n = int(input())
a = []
for i in range(n * 10 - n, n * 10):
	a.append(i)
print(' '.join(map(str, a)))


n = int(input())
l = [x for x in range(10 ** 7, 10 ** 7 - n, -1)]
l.sort(reverse=False)
print(*l)


import sys
for i in range(int(sys.stdin.readline())):
	print(10 ** 5 + i)


n = int(input())
for i in range(n):
	print(6000000 + i)


from sys import stdin, stdout
import math, sys
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict, Counter
from os import path
import bisect as bi
import heapq
mod = 10 ** 9 + 7

def yes():
	print('YES')

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

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

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

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

	def minp():
		return map(int, stdin.readline().split())
n = inp()
for i in range(n, 0, -1):
	print(7 ** 7 - i, end=' ')


n = int(input())
N = 1300000
prime = [True for i in range(N + 1)]
p = 2
while p * p <= N:
	if prime[p] == True:
		for i in range(p * 2, N + 1, p):
			prime[i] = False
	p += 1
prime[0] = False
prime[1] = False
res = []
i = 2
n1 = 0
res = []
while n:
	if prime[i]:
		res.append(i)
		n -= 1
	i += 1
print(*res)


n = int(input())
print(*[*range(n, 2 * n)])


n = int(input())
print(' '.join([str(3 * n + i) for i in range(1, n + 1)]))


def hungry_sequence(n):
	array = range(2 * n, 3 * n, 1)
	print(*array)
n = input()
hungry_sequence(int(n))


n = int(input())
seq = [100000]
for i in range(0, n - 1):
	seq.append(seq[i] + 1)
print(' '.join(map(str, seq)))


for i in range(int(input())):
	print(10 ** 5 + i)


def main():
	first_line = input()
	first_line = first_line.split()
	n = int(first_line[0])
	output = ''
	start = 200001
	for i in range(n):
		output += str(start) + ' '
		start += 1
	print(output)
main()


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


st = 10 ** 5
n = int(input())
for i in range(st, st + n):
	print(i, end=' ')
print()


import sys
n = int(sys.stdin.readline())
num = 10 ** 6 + 1
for i in range(n):
	print(num, end=' ')
	num += 1


a = int(input())
print(' '.join(map(str, range(a, 2 * a))))


n = int(input())
for i in range(n):
	print(3 * n + i)


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


import sys
from bisect import bisect_left, bisect_right
from collections import deque, Counter
from math import gcd, sqrt, factorial, ceil, log10
from itertools import permutations
inf = float('inf')
mod = 1000000007
mini = 1000000007

def fact(n):
	if n == 0:
		return 1
	p = 1
	d = 10 ** 9 + 7
	for i in range(1, n + 1):
		p = p * i
		p = p % d
	return p

def ncr(n, r):
	d = 10 ** 9 + 7
	num = fact(n)
	den = fact(r) * fact(n - r) % d
	den = pow(den, d - 2, d)
	return num * den % d

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

def binary(number):
	result = 0
	while number:
		result = result + 1
		number = number & number - 1
	return result

def calculate_factors(n):
	hh = [1] * (n + 1)
	p = 2
	while p * p < n:
		if hh[p] == 1:
			for i in range(p * 2, n, p):
				hh[i] = 0
		p += 1
	total = 1
	for p in range(2, n + 1):
		if hh[p] == 1:
			count = 0
			if n % p == 0:
				while n % p == 0:
					n = int(n / p)
					count += 1
				total *= count + 1
	return total

def prime_factors(n):
	i = 2
	factors = set()
	while i * i <= n:
		if n % i:
			i += 1
		else:
			factors.add(n // i)
			n = n // i
			factors.add(i)
	if n > 1:
		factors.add(n)
	return factors

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

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

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

def input():
	return sys.stdin.readline().strip()
myArr = sieve(1299710)
n = int(input())
for i in range(n):
	print(myArr[i], end=' ')


def hungrySequence(n):
	li = range(n, 2 * n, 1)
	print(*li)
hungrySequence(int(input()))


n = int(input())
p = 999999
for i in range(n):
	print(p)
	p += 1


n = int(input())
for i in range(1, n + 1):
	print(1000000 + i)


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():
	res = []
	n = 123457
	k = inp()
	for i in range(k):
		res.append(n * 3 + i)
	print(*res)
BUFSIZE = 8192

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

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

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

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

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


n = int(input())
for i in range(10 ** 5 + 1, 10 ** 9):
	if n > 0:
		print(i, end=' ')
		n -= 1
	else:
		break


import sys
n = int(input())
sys.stdout.write(str(n))
for i in range(n + 1, n * 2):
	sys.stdout.write(' ' + str(i))


n = int(input())
b = []
for i in range(100000, 100000 + n):
	b.append(i)
print(*b)


while 1:
	try:
		n = int(input())
		for i in range(0, n):
			print(11 * n + i, end=' ')
		print('')
	except EOFError:
		break


import sys
input = sys.stdin.readline

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

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

def nCr(n, k):
	if k > n:
		return 0
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0, hi=None):
	if hi == None:
		hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

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

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	(prime[0], prime[1]) = (False, False)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

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

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

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
from itertools import permutations
import math
from bisect import bisect_left

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


n = int(input())
i = 1
res = []
count = 0
while count < n:
	res.append(str(n + i))
	count += 1
	i += 1
print(' '.join(res))


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

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

def S():
	return str(input())

def L():
	return list(R())
from collections import Counter
import math
import sys
from itertools import permutations
n = I()
for i in range(n + 1, n * 2 + 1):
	print(i, end=' ')


n = int(input())
a = []
prime = [True for i in range(1299829)]
p = 2
while p * p <= 1299828:
	if prime[p] == True:
		for i in range(p * p, 1299828, p):
			prime[i] = False
	p += 1
for i in range(2, 1299828):
	if prime[i] == True:
		a.append(i)
print(*a[:n], end=' ')


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


def Hungry(n):
	return 3 * n

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


def generate_primes(n):
	sieve = [1] * n
	for i in range(3, int(n ** 0.5) + 1, 2):
		if sieve[i]:
			sieve[i * i::2 * i] = [0] * ((n - i * i - 1) // (2 * i) + 1)
	return [2] + [i for i in range(3, n, 2) if sieve[i]]
print(*generate_primes(1300000)[:int(input())])


print(' '.join([str(10000000 - i) for i in range(int(input()), 0, -1)]))


a = int(input())
for i in range(a, a * 2):
	print(i)


n = int(input())
l3 = [i for i in range(n * 4, n * 4 + n)]
print(*l3)


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

def power(x, n):
	return reduce(mul, [x for i in range(n)])
from functools import *
from operator import *
m = int(input())
for i in range(m):
	print(i + m, end=' ')


n = int(input())
ans = []
if n == 1:
	m = 3
else:
	m = n
start = n
while len(ans) < n:
	if start % m != 0:
		ans.append(start)
	start += 1
for n in ans:
	print(n, end=' ')


n = int(input())
print(' '.join(map(str, [n + t for t in range(n)])))


print(*[i for i in range(10 ** 6 - int(input()), 10 ** 6)])


max = 10 ** 5
a = int(input())
for x in range(a):
	print(max + x, end=' ')


n = int(input())
for index in range(4 * n, 5 * n):
	print(index, end=' ')


n = int(input())
ans = [int(10000000.0) - i for i in range(n)][::-1]
print(' '.join(map(str, ans)))


z = input
mod = 10 ** 9 + 7
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f

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

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0:
			return 0
	return 1
z = input
mod = 10 ** 9 + 7
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f

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

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0:
			return 0
	return 1
n = int(z())
l = [0] * n
i = 3
j = 0
if n > 1000:
	while True:
		print(300000 + j, end=' ')
		j += 1
		if j == n:
			exit()
while j != n:
	if prime(i) == 1:
		l[j] = i
		j += 1
	i += 1
print(*l)


x = int(input())
while x:
	print(7 ** 7 - x)
	x -= 1


import sys
import math
p = sys.stdin.readline()
n = int(p)
m = len(p) - 1
k = []
for i in range(n):
	k.append(str(10 ** m + i))
print(' '.join(k))


import math
n = int(input())
num = math.ceil((n * 2) ** 0.5)
prime = []
i = 2
while len(prime) < num:
	f = True
	for j in prime:
		if i % j == 0:
			f = False
			break
	if f:
		prime.append(i)
	i += 1
ans = []
i = 0
j = 0
while len(ans) < n:
	ans.append(prime[i] * prime[j])
	j += 1
	if j == len(prime):
		i += 1
		j = i
for i in sorted(ans):
	print(i, end=' ')
print()


print(*(str(100000 + i) for i in range(int(input()))))


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


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


a = int(input())
for i in range(a):
	print(100000 + i)


n = int(input())
arr = [str(n + i) for i in range(0, n)]
print(' '.join(arr))


import sys
sys.setrecursionlimit(10 ** 5)
inf = int(10 ** 7)
max_val = inf
min_val = -inf
RW = lambda : sys.stdin.readline().strip()
RI = lambda : int(RW())
RMI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
RWI = lambda : [x for x in sys.stdin.readline().strip().split()]
from math import gcd, floor
n = int(input())
for i in range(n, n + n):
	print(i, end=' ')


n = int(input())
a = list(range(n, 2 * n))
print(' '.join(map(str, a)))


n = int(input())
N = 10000000
for i in range(N - n, N, 1):
	print(i)


n = int(input())
for i in range(n):
	print(5000000 + i)


import math
n = int(input())
for i in range(3 * n, 3 * n + n):
	print(i, end=' ')


n = int(input())
y = 0
a = [3 * n]
while len(a) != n:
	a.append(a[-1] + 1)
if len(a) > n:
	a.pop()
for i in a:
	print(i, end=' ')
print()


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


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

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

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

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

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

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

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

def input():
	return sys.stdin.readline().rstrip('\r\n')
n = inp()
for i in range(n, n + n):
	print(i, end=' ')
print()


n = int(input())
ans = []
for i in range(3 * n, 4 * n):
	ans.append(str(i))
print(' '.join(ans))


n = int(input())
a = 10 ** 7 - 10 ** 5
b = 10 ** 7
for i in range(a, a + n):
	print(i, end=' ')


mod = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
n = ii()
for i in range(1000000, 1000000 + n):
	print(i, end=' ')


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


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


def SieveOfEratosthenes(z, n):
	prime = [True for i in range(z + 1)]
	p = 2
	while p * p <= z:
		if prime[p] == True:
			for i in range(p * p, z + 1, p):
				prime[i] = False
		p += 1
	lis = []
	for p in range(2, z + 1):
		if prime[p]:
			if len(lis) < n:
				lis.append(p)
				print(p, end=' ')
			else:
				break
n = int(input())
SieveOfEratosthenes(1299709, n)


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


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


x = int(input())
string = ''
for i in range(x, 2 * x):
	string += str(i)
	string += ' '
print(string.strip())


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


print(' '.join(map(str, [100000 + i for i in range(int(input()))])))


n = int(input())
m = 10 ** 6 + 1
for i in range(n - 1):
	print(m, end=' ')
	m += 1
print(m)


from sys import stdin, stdout

def Prime(num):
	if num <= 3:
		return True
	i = 5
	while i ** 2 <= num:
		if num % i == 0 or num % (i + 2) == 0:
			return False
		i += 6
	return True
n = int(stdin.readline())
for num in range(3, 10 ** 7, 2):
	if num % 3 == 0:
		continue
	if Prime(num):
		print(num, end=' ')
		n -= 1
		if n == 0:
			break


from sys import stdin
from sys import stdout

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

def gtis():
	return tuple(map(int, stdin.readline().strip().split()))

def gstr():
	return stdin.readline().strip().split()

def gi():
	return int(stdin.readline().strip())

def gcl():
	s = stdin.readline().strip().split()
	return list(s[:len(s) - 1])

def p(x, end='\n'):
	stdout.write(str(x) + end)

def pi(s):
	p(' '.join(map(str, s)))

def main():
	n = gi()
	i = 1000000
	while n > 0:
		print(i)
		n -= 1
		i += 1
main()


n = int(input())
i = 10000000 - n
while i < 10000000:
	print(i, end=' ')
	i += 1


n = int(input())
(i, i1) = (100000, 0)
while i1 < n:
	print(i, end=' ')
	i += 1
	i1 += 1


n = int(input())
a = []
c = 0
for i in range(130000, 10 ** 7):
	a.append(i)
	c += 1
	if c == n:
		break
print(*a)


n = int(input())
a = []
b = [1] * 10000000
for i in range(2, 10000000):
	if b[i] == 1:
		a.append(i)
	if len(a) == n:
		break
	for x in a:
		if x * i < 10000000:
			b[x * i] = 0
		else:
			break
print(*a)


n = int(input())
ans = []
c = 10 ** 7
for i in range(n):
	ans.append(c)
	c = c - 1
print(*ans[::-1])


x = 10 ** 6 + 2
ans = [x]
x += 1
n = int(input())
while len(ans) < n:
	ans.append(x)
	x += 1
for i in ans:
	print(i, end=' ')


n = int(input())
k = 10 ** 7 - n + 1
for i in range(k, 10 ** 7 + 1):
	print(i, end=' ')


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


n = int(input())
s = []
for i in range(n):
	s.append(str(10 ** 5 + i))
print(' '.join(s))


n = int(input())
print(' '.join(map(str, range(n + 1, n * 2 + 1))))


import math
r = int(input())
l = [i for i in range(100000, 100000 + r)]
print(*l)


import sys
import itertools
import math
import collections
from collections import Counter
input = sys.stdin.readline

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

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

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

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

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

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

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

def prr(a, sep=' '):
	print(sep.join(map(str, a)))

def dd():
	return collections.defaultdict(int)
prr(sieve(1400000)[:ii()])


from collections import Counter
import string
import math

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

def vary(number_of_variables):
	if number_of_variables == 1:
		return int(input())
	if number_of_variables >= 2:
		return map(int, input().split())

def makedict(var):
	return dict(Counter(var))
mod = 1000000007
n = vary(1)
if n == 1:
	print(1)
elif n > 1 and n <= 10:
	for i in range(10, 10 + n, 1):
		print(i, end=' ')
elif n > 10 and n <= 100:
	for i in range(100, 100 + n, 1):
		print(i, end=' ')
elif n > 100 and n <= 1000:
	for i in range(1000, 1000 + n, 1):
		print(i, end=' ')
elif n > 1000 and n <= 10000:
	for i in range(10000, 10000 + n, 1):
		print(i, end=' ')
elif n > 10000 and n <= 100000:
	for i in range(100000, 100000 + n, 1):
		print(i, end=' ')
elif n > 100000 and n <= 1000000:
	for i in range(1000000, 1000000 + n, 1):
		print(i, end=' ')
else:
	pass


def hungrySequence():
	n = int(input())
	print(*range(n, n + n))
hungrySequence()


import math

def isPrime(n):
	if n == 1 or n == 3 or n == 5:
		return True
	sqn = int(math.sqrt(n)) + 1
	for i in range(3, sqn, 2):
		if n % i == 0:
			return False
	return True
n = int(input())
i = 3
count = 0
arr = []
while count < n:
	if isPrime(i):
		arr.append(i)
		count += 1
	i += 2
for ele in arr:
	print(ele, end=' ')


n = int(input())
string = ''
string += str(n) + ' '
for i in range(n + 1, n * 2):
	string += str(i) + ' '
print(string)


def SieveOfEratosthenes(n):
	all_prime = []
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p]:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	for p in range(2, n):
		if prime[p]:
			all_prime.append(p)
	return all_prime
l = SieveOfEratosthenes(2 * 10 ** 6)
n = int(input())
for i in range(n):
	print(l[i], end=' ')


n = int(input())
for i in range(10 ** 7 - n, 10 ** 7):
	print(i, end=' ')


n = int(input())
for x in range(1, n + 1):
	print(10 ** 5 + x)


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


n = int(input())
list = []
for j in range(n):
	list.append(n + j)
print(*list)


def main():
	n = int(input())
	ans = []
	for i in range(10000000 - n, 10000000):
		ans.append(str(i))
	print(' '.join(ans))
main()


n = int(input())
for i in range(3 * n, 4 * n):
	print(i, end=' ')


def hungry(n):
	i = 3 * n
	for k in range(n):
		print(i + k, end=' ')
hungry(int(input()))


n = int(input())
seq = [i for i in range(n, n * 2)]
for elem in seq:
	print(elem, end=' ')


n = int(input())
l = [i for i in range(n, 2 * n)]
print(*l)


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


t = int(input())
for i in range(1, t + 1, 1):
	print(3 * t + i, end=' ')


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


n = int(input())
print(' '.join(map(str, range(10000000 - n, 10000000))))


import sys

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

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

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

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))
n = iinput()
for i in range(n):
	print(3 * n + i, end=' ')


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


def prime_sieve(n):
	flag = n % 6 == 2
	sieve = bytearray((n // 3 + flag >> 3) + 1)
	for i in range(1, int(n ** 0.5) // 3 + 1):
		if not sieve[i >> 3] >> (i & 7) & 1:
			k = 3 * i + 1 | 1
			for j in range(k * k // 3, n // 3 + flag, 2 * k):
				sieve[j >> 3] |= 1 << (j & 7)
			for j in range(k * (k - 2 * (i & 1) + 4) // 3, n // 3 + flag, 2 * k):
				sieve[j >> 3] |= 1 << (j & 7)
	return sieve

def prime_list(n):
	res = []
	if n > 1:
		res.append(2)
	if n > 2:
		res.append(3)
	if n > 4:
		sieve = prime_sieve(n + 1)
		res.extend((3 * i + 1 | 1 for i in range(1, (n + 1) // 3 + (n % 6 == 1)) if not sieve[i >> 3] >> (i & 7) & 1))
	return res
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

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

def In():
	return int(input())

def func():
	pass

def main():
	n = In()
	print(*prime_list(1300000)[:n])
	return
main()


n = int(input())
ans = ''
for i in range(n):
	ans += str(3 * n + i) + ' '
print(ans)


n = int(input())
p = 100000
l = []
for i in range(n):
	l.append(p)
	p = p + 1
print(*l)


n = int(input())
while n > 0:
	print(7 ** 7 - n)
	n -= 1


from collections import deque, Counter, OrderedDict
from heapq import nsmallest, nlargest, heapify, heappop, heappush, heapreplace
from math import ceil, floor, log, log2, sqrt, gcd, factorial, pow, pi
from bisect import bisect_left, bisect_right
import io, os, sysconfig

def binNumber(n, size=4):
	return bin(n)[2:].zfill(size)

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

def ini():
	return int(input())

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

def sti():
	return str(input())

def par(a):
	print(' '.join(list(map(str, a))))

def tdl(outerListSize, innerListSize, defaultValue=0):
	return [[defaultValue] * innerListSize for i in range(outerListSize)]

def sts(s):
	s = list(s)
	s.sort()
	return ''.join(s)

def bis(a, x):
	i = bisect_left(a, x)
	if i != len(a) and a[i] == x:
		return [i, True]
	else:
		return [-1, False]

class pair:

	def __init__(self, f, s):
		self.fi = f
		self.se = s

	def __lt__(self, other):
		return (self.fi, self.se) < (other.fi, other.se)
n = ini()
for i in range(n + 1, 2 * n + 1):
	print(i, end=' ')


import collections

def solve(k):
	ans = ''
	c = 3 * k
	p = 3 * k
	for i in range(k):
		if c % p == 0:
			c = p * 2 + k + 1
			p = p * 2 + k
		ans += str(c) + ' '
		c += 1
	return ans

def sort(key):
	return key[0]
ans = []
n = int(input())
ans.append(solve(n))
for i in ans:
	print(i)


print(*[i for i in range(10 ** 7 - int(input()), 10 ** 7)])


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


start_number = 10 ** 6
n = int(input())
res = [x for x in range(start_number, start_number + n)]
string = ''
for x in res:
	string += str(x) + ' '
print(string)


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


def genPrimes(n):
	sieve = [True] * (n + 1)
	p = 2
	while p * p <= n:
		if sieve[p]:
			for i in range(p * p, n + 1, p):
				sieve[i] = False
		p += 1
	primes = []
	for i in range(2, n + 1):
		if sieve[i]:
			primes.append(i)
	return primes
primes = genPrimes(2000000)
n = int(input().strip())
print(*primes[:n])


import os
import sys
from io import BytesIO, IOBase

def main():
	n = int(input())
	for i in range(10 ** 7 - n, 10 ** 7):
		print(i, end=' ')

def nouse0():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')

def nouse1():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')

def nouse2():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def nouse3():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')

def nouse4():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')

def nouse5():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')
main()


n = int(input())
a = [i for i in range(n, n * 2)]
print(' '.join(map(str, a)))


n = int(input())
print(*list(range(10 ** 5 + 1, n + 10 ** 5 + 1)))


import sys
input = lambda : sys.stdin.readline().strip('\r\n')
p = 10 ** 5 + 10
n = int(input())
for i in range(n):
	print(p + i, end=' ')
print()


def hungry(n):
	seq = [i for i in range(n, n * 2)]
	return seq
n = int(input())
seq = hungry(n)
for elem in seq:
	print(elem, end=' ')


import math as m
n = int(input())
ans = []
for i in range(1, n + 1):
	ans.append(7 * n + i)
print(*ans)


import sys
from collections import Counter
input = sys.stdin.readline

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

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

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

def invr():
	return map(int, input().split())
N = inp()
lim = 1299709
arr = [True for i in range(lim + 1)]
arr[0] = False
arr[1] = False
for i in range(2, int(lim ** 0.5) + 1, 1):
	if arr[i]:
		for j in range(i ** 2, lim + 1, i):
			arr[j] = False
n = 0
k = 2
while n != N:
	if arr[k]:
		print(k, end=' ')
		n += 1
	k += 1


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

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

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

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

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

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

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

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

def S():
	return input()

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

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

def main():
	n = I()
	return ' '.join(map(str, range(n, n * 2)))
print(main())


def hungry(n):
	a = 10 ** 7
	b = list()
	for i in range(n):
		b.append(a - n + i + 1)
	return b
print(*hungry(int(input())))


t = int(input())
h = [100000]
a = h[0]
print(int(h[0]), end=' ')
for i in range(1, t):
	a += 1
	print(a, end=' ')


def solve():
	n = int(input())
	i = 0
	z = n
	while i < z:
		print(n, end=' ')
		n += 1
		i += 1
try:
	solve()
except:
	pass


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


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


n = int(input())
print(' '.join((str(x) for x in range(3 * n, 4 * n))))


n = int(input())

def sieve(n):
	arr = [True] * 1299710
	p = 2
	while p * p <= 1299710:
		if arr[p]:
			for i in range(p * p, 1299710, p):
				arr[i] = False
		p += 1
	ans = []
	i = 2
	while len(ans) != n:
		if arr[i]:
			ans.append(i)
		i += 1
	return ans
print(*sieve(n))


n = int(input())
t = 200001
for i in range(t, t + n):
	print(i)


k = int(input())
for i in range(100005, 100005 + k):
	print(i, end=' ')


def primes(n):
	p = [True] * n
	for x in range(3, int(n ** 0.5) + 1, 2):
		if p[x]:
			p[x * x::2 * x] = [False] * ((n - x * x - 1) // (2 * x) + 1)
	return [2] + [i for i in range(3, n, 2) if p[i]]
s = ''
for x in primes(1300000)[:int(input())]:
	s += str(x) + ' '
print(s)


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


n = int(input())
if n <= 1000:
	p = 1001
	while n > 0:
		print(p, end=' ')
		n -= 1
		p += 1
else:
	p = n
	while n > 0:
		print(p, end=' ')
		n -= 1
		p += 1


n = int(input())
a = 100001
i = 0
while i < n:
	print(a, end=' ')
	a += 1
	i += 1


n = int(input())
for i in range(1, n + 1):
	print(10 ** 5 + i)


i = 0
lit = list()
n = int(input())
for j in range(n):
	lit.append(str(2 * n + i))
	i += 1
print(' '.join(lit))


x = 3 * 10 ** 5
n = int(input())
for i in range(n):
	print(x + i, end=' ')
print('')


n = int(input())
arr = [x for x in range(10 ** 7 - n, 10 ** 7)]
for i in range(n):
	print(arr[i], end=' ')


import math
n = int(input())
l = []

def sieve(n, x):
	prime = [True] * (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
	l = []
	for i in range(2, n):
		if prime[i] == True:
			l.append(i)
			if len(l) == x:
				return l
	return l
xs = sieve(1300000, n)
print(*xs)


n = int(input())
k = n + 1
for _ in range(n):
	print(k)
	k += 1


T_ON = 0
DEBUG_ON = 0
MOD = 998244353

def solve():
	n = read_int()
	base = 10 ** 7 - n
	A = [base + i for i in range(n)]
	print_nums(A)

def main():
	T = read_int() if T_ON else 1
	for i in range(T):
		solve()

def dbg(*xargs):
	if DEBUG_ON:
		print(*xargs)
from collections import *
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

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

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

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

def YES():
	print('YES')

def Yes():
	print('Yes')

def NO():
	print('NO')

def No():
	print('No')

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

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

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

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

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

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

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

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

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

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

def is_prime(n):
	if n == 1:
		return False
	for i in range(2, int(n ** 0.5) + 1):
		if n % i:
			return False
	return True

def gen_primes(n):
	P = [True for _ in range(n + 1)]
	P[0] = P[1] = False
	for i in range(int(n ** 0.5) + 1):
		if P[i]:
			for j in range(2 * i, n + 1, i):
				P[j] = False
	return P
main()


n = int(input())
solution = [str(n + a) for a in range(n)]
print(' '.join(solution))


n = int(input())
for i in range(n):
	print(3 * n + i, end='\t')


import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def value():
	return tuple(map(int, input().split()))

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

def Int():
	return int(input())

def Str():
	return input()

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

def prime(n):
	pr = [True] * (n + 1)
	pr[0] = False
	pr[1] = False
	p = 2
	while p * p <= n:
		if pr[p] == True:
			for j in range(p * p, n + 1, p):
				pr[j] = False
		p += 1
	return [i for i in range(len(pr)) if pr[i]]
a = 10 ** 6
for i in range(Int()):
	print(a, end=' ')
	a += 1
print()


import math
n = int(input())
print(*range(n, 2 * n))


n = int(input())
ans = []
for i in range(n):
	ans.append(10 ** 7 - n + i + 1)
print(' '.join((str(ans[i]) for i in range(n))))


__copyright__ = ''
__author__ = 'Son-Huy TRAN'
__email__ = 'sonhuytran@gmail.com'
__doc__ = ''
__version__ = '1.0'

def main() -> int:
	n = int(input())
	for i in range(n, n * 2):
		print(i, end=' ')
	return 0
exit(main())


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

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

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

def sip():
	return input()

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

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

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

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

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

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

def dic(arr):
	return Counter(arr)
n = ip()
count = 0
for i in range(n):
	print(3 * (n + count), end=' ')
	count += 1


import math
n = int(input())

def is_prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(n ** 0.5) + 1
	for divisor in range(3, sqr, 2):
		if n % divisor == 0:
			return False
	return True
arr = []
for i in range(2, 10 ** 7):
	if len(arr) == n:
		print(*arr)
		exit()
	if is_prime(i) is True:
		arr.append(i)


n = int(input())
print(*range(n, n + n))


import sys
n = int(sys.stdin.readline())
ans = []
cnt = 100001
while n > 0:
	ans.append(cnt)
	n -= 1
	cnt += 1
print(*ans)


n = int(input())
while n:
	print(10 ** 7 - n, end=' ')
	n -= 1


n = int(input())
answer = []
for i in range(n):
	print(i + n * 10, end=' ')


n = int(input().strip())
ans = []
i = 0
while len(ans) < n:
	ans.append(3 * n + i)
	i += 1
print(*ans)


n = int(input())
a = []
for i in range(n):
	a.append(str(3 * n + i))
print(' '.join(a))


def soe(n):
	arr = []
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 1
	prime[0] = False
	prime[1] = False
	for p in range(n + 1):
		if prime[p]:
			arr.append(p)
	return arr
n = int(input())
arr = soe(1500000)
for i in range(n):
	(print(arr[i], end=' '),)


from __future__ import division, print_function
import math
import os
import sys
from fractions import *
from sys import *
from decimal import *
from io import BytesIO, IOBase
from itertools import *
from collections import *
M = 10 ** 9 + 7
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
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')

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 regularbracket(t):
	p = 0
	for i in t:
		if i == '(':
			p += 1
		else:
			p -= 1
		if p < 0:
			return False
	else:
		if p > 0:
			return False
		else:
			return True

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

def reverse1(string):
	pp = ''
	for i in string[::-1]:
		pp += i
	if pp == string:
		return True
	return False

def reverse2(list1):
	l = []
	for i in list1[::-1]:
		l.append(i)
	if l == list1:
		return True
	return False

def mex(list1):
	p = max(list1) + 1
	for i in range(len(list1)):
		if list1[i] != i:
			p = i
			break
	return p

def sumofdigits(n):
	n = str(n)
	s1 = 0
	for i in n:
		s1 += int(i)
	return s1

def perfect_square(n):
	s = math.sqrt(n)
	if s == int(s):
		return True
	return False

def roman_number(x):
	if x > 15999:
		return
	value = [5000, 4000, 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
	symbol = ['F', 'MF', 'M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']
	roman = ''
	i = 0
	while x > 0:
		div = x // value[i]
		x = x % value[i]
		while div:
			roman += symbol[i]
			div -= 1
		i += 1
	return roman

def soretd(s):
	for i in range(1, len(s)):
		if s[i - 1] > s[i]:
			return False
	return True

def countRhombi(h, w):
	ct = 0
	for i in range(2, h + 1, 2):
		for j in range(2, w + 1, 2):
			ct += (h - i + 1) * (w - j + 1)
	return ct

def countrhombi2(h, w):
	return h * h // 4 * (w * w // 4)

def binpow(a, b):
	if b == 0:
		return 1
	else:
		res = binpow(a, b // 2)
	if b % 2 != 0:
		return res * res * a
	else:
		return res * res

def binpowmodulus(a, b, m):
	a %= m
	res = 1
	while b > 0:
		if b & 1:
			res = res * a % m
		a = a * a % m
		b >>= 1
	return res

def coprime_to_n(n):
	result = n
	i = 2
	while i * i <= n:
		if n % i == 0:
			while n % i == 0:
				n //= i
			result -= result // i
		i += 1
	if n > 1:
		result -= result // n
	return result

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

def luckynumwithequalnumberoffourandseven(x, n, a):
	if x >= n and str(x).count('4') == str(x).count('7'):
		a.append(x)
	elif x < 1000000000000.0:
		luckynumwithequalnumberoffourandseven(x * 10 + 4, n, a)
		luckynumwithequalnumberoffourandseven(x * 10 + 7, n, a)
	return a

def luckynum(x, l, r, a):
	if x >= l and x <= r:
		a.append(x)
	if x > r:
		a.append(x)
		return a
	if x < 10000000000.0:
		luckynum(x * 10 + 4, l, r, a)
		luckynum(x * 10 + 7, l, r, a)
	return a

def luckynuber(x, n, a):
	p = set(str(x))
	if len(p) <= 2:
		a.append(x)
	if x < n:
		luckynuber(x + 1, n, a)
	return a

def interact(type, x):
	if type == 'r':
		inp = input()
		return inp.strip()
	else:
		print(x, flush=True)

def findTrailingZeros(n):
	count = 0
	while n >= 5:
		n //= 5
		count += n
	return count

def mergeSort(arr):
	if len(arr) > 1:
		mid = len(arr) // 2
		L = arr[:mid]
		R = arr[mid:]
		mergeSort(L)
		mergeSort(R)
		i = j = k = 0
		while i < len(L) and j < len(R):
			if L[i] < R[j]:
				arr[k] = L[i]
				i += 1
			else:
				arr[k] = R[j]
				j += 1
			k += 1
		while i < len(L):
			arr[k] = L[i]
			i += 1
			k += 1
		while j < len(R):
			arr[k] = R[j]
			j += 1
			k += 1
res = set()

def solven(p, l, a, b, n):
	if p > n or l > 10:
		return
	if p > 0:
		res.add(p)
	solven(p * 10 + a, l + 1, a, b, n)
	solven(p * 10 + b, l + 1, a, b, n)

def subsetsUtil(A, subset, index, d):
	print(*subset)
	s = sum(subset)
	d.append(s)
	for i in range(index, len(A)):
		subset.append(A[i])
		subsetsUtil(A, subset, i + 1, d)
		subset.pop(-1)
	return d

def subsetSums(arr, l, r, d, sum=0):
	if l > r:
		d.append(sum)
		return
	subsetSums(arr, l + 1, r, d, sum + arr[l])
	subsetSums(arr, l + 1, r, d, sum)
	return d

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

def calc(X, d, ans, D):
	if len(X) == 0:
		return
	i = X.index(max(X))
	ans[D[max(X)]] = d
	Y = X[:i]
	Z = X[i + 1:]
	calc(Y, d + 1, ans, D)
	calc(Z, d + 1, ans, D)

def factorization(n, l):
	c = n
	if prime(n) == True:
		l.append(n)
		return l
	for i in range(2, c):
		if n == 1:
			break
		while n % i == 0:
			l.append(i)
			n = n // i
	return l

def good(b):
	l = []
	i = 0
	while len(b) != 0:
		if b[i] < b[len(b) - 1 - i]:
			l.append(b[i])
			b.remove(b[i])
		else:
			l.append(b[len(b) - 1 - i])
			b.remove(b[len(b) - 1 - i])
	if l == sorted(l):
		return True
	return False

def generate(st, s):
	if len(s) == 0:
		return
	if s not in st:
		st.add(s)
		for i in range(len(s)):
			t = list(s).copy()
			t.remove(s[i])
			t = ''.join(t)
			generate(st, t)
	return

def largestincreasingsubsequence(A):
	l = [1] * len(A)
	sub = []
	for i in range(1, len(l)):
		for k in range(i):
			if A[k] < A[i]:
				sub.append(l[k])
		l[i] = 1 + max(sub, default=0)
	return max(l, default=0)

def findOR(nums, N):
	prefix_sum = 0
	result = 0
	for i in range(N):
		result |= nums[i]
		prefix_sum += nums[i]
		result |= prefix_sum
	return result

def OR(a, n):
	ans = a[0]
	for i in range(1, n):
		ans |= a[i]
	return ans

def main():
	n = inpu()
	l = []
	for i in range(10 ** 7 - 1, 0, -1):
		l.append(i)
		if len(l) == n:
			break
	l.sort()
	print(*l)
main()


def run():
	m = int(input())
	for i in range(m, m + m):
		print(i, end=' ')
run()


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


n = 100000
e = int(input())
for x in range(e):
	print(n * 3 + x)


n = int(input())
limit = 13 * n
l2 = [0 for i in range(0, limit)]
p = 2
while p < limit:
	x = p * p
	while x < limit:
		l2[x] = 1
		x = x + p
	for i in range(p + 1, limit):
		if l2[i] == 0:
			p = i
			break
	else:
		p = limit
l3 = [0 for i in range(0, n)]
count = 0
for i in range(2, limit):
	if l2[i] == 0:
		l3[count] = i
		count += 1
		if count == n:
			break
print(*l3)