Problem:
 Score: 400 points    Problem Statement  Print a sequence a_1, a_2, ..., a_N whose length is N that satisfies the following conditions:   a_i  (1 \leq i \leq N) is a prime number at most 55  555 .  The values of a_1, a_2, ..., a_N are all different.  In every choice of five different integers from a_1, a_2, ..., a_N , the sum of those integers is a composite number.   If there are multiple such sequences, printing any of them is accepted.      Notes  An integer N not less than 2 is called a prime number if it cannot be divided evenly by any integers except 1 and N , and called a composite number otherwise.      Constraints   N is an integer between 5 and 55 (inclusive).         Input  Input is given from Standard Input in the following format:  N       Output  Print N numbers a_1, a_2, a_3, ..., a_N in a line, with spaces in between.        Sample Input 1 5      Sample Output 1 3 5 7 11 31  Let us see if this output actually satisfies the conditions. First, 3 , 5 , 7 , 11 and 31 are all different, and all of them are prime numbers. The only way to choose five among them is to choose all of them, whose sum is a_1+a_2+a_3+a_4+a_5=57 , which is a composite number. There are also other possible outputs, such as 2 3 5 7 13 , 11 13 17 19 31 and 7 11 5 31 3 .       Sample Input 2 6      Sample Output 2 2 3 5 7 11 13   2 , 3 , 5 , 7 , 11 , 13 are all different prime numbers.  2+3+5+7+11=28 is a composite number.  2+3+5+7+13=30 is a composite number.  2+3+5+11+13=34 is a composite number.  2+3+7+11+13=36 is a composite number.  2+5+7+11+13=38 is a composite number.  3+5+7+11+13=39 is a composite number.   Thus, the sequence 2 3 5 7 11 13 satisfies the conditions.       Sample Input 3 8      Sample Output 3 2 5 7 13 19 37 67 79

Solution (Python):
n = int(input())
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]
lis = []
for a in A:
    if a%5 == 1:
        lis.append(a)
print(*lis[:n],sep = " ")

Solution (Python):
n=int(input())
prime=[2]
no=3
mod1=[]
mod2=[2]
mod3=[]
mod4=[]
while len(mod1)<n and len(mod2)<n and len(mod3)<n and len(mod4)<n:
  for i in prime:
    if(no%i==0):
      no+=1
      break
  else:
    prime.append(no)
    if(no%5==1):
      mod1+=[no]
    elif(no%5==2):
      mod2+=[no]
    elif(no%5==3):
      mod3+=[no]
    elif(no%5==4):
      mod4+=[no]
    no+=1
if(len(mod1)==n):
  ans=mod1
elif(len(mod2)==n):
  ans=mod2
elif(len(mod3)==n):
  ans=mod3
elif(len(mod4)==n):
  ans=mod4
for i in ans:
  print(i,end=' ')

Solution (Python):
N = int(input())
def prime_table(n):
    list = [True for _ in range(n+1)]
    for i in range(2,int(n**0.5)+1):
        if list[i]:
            j = i*2
            while j<=n:
                list[j] = False
                j += i
    table = [i for i in range(n+1) if list[i] and i>=2]
    return table

table = prime_table(55555)
table_ = []
for i in range(len(table)):
    if table[i]%5==1:
        table_.append(table[i])
for i in range(N):
    print(table_[i],end=' ')
print('')

Solution (Python):
def d_five_five_everywhere(N):
    def prime_table(n):  
        is_prime = [True] * (n + 1)
        is_prime[0] = is_prime[1] = False  
        for j in range(2, int(n**0.5) + 1):
            if not is_prime[j]:
                continue
            for k in range(j * 2, n + 1, j):
                is_prime[k] = False  
        return [i for i in range(n + 1) if is_prime[i]]

    prime_mod5_is_1 = [p for p in prime_table(55555) if p % 5 == 1]
    return ' '.join(map(str, prime_mod5_is_1[:N]))

N = int(input())
print(d_five_five_everywhere(N))

Solution (Python):
n = int(input())

import math
import itertools
sosu = [0]*2 + [1]*(10**5)

for i, item in enumerate(sosu):
  if i > math.sqrt(len(sosu)):
    break
  if item:
    for j in range(2, len(sosu)//i):
      sosu[j*i] = 0

sosu_num = []
for i in range(len(sosu)):
  if sosu[i] and i % 5 == 1:
    sosu_num.append(i)

ans = sosu_num[:n]
for item in ans:
  print(item, end=" ")

Solution (Python):
n = int(input())
k = 0
ans = []

def prime(p):
  j = 2
  while j * j <= p:
    if p % j == 0:
      return False
    j += 1
  return True

for i in range(6, 55556, 5):
  if k == n:
    break
  if prime(i):
    ans.append(i)
    k += 1

print(*ans)

Solution (Python):
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline



def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [N] = [int(input_raw[0])]
    primes = []
    for i in range(2, 55556):
        is_prime = True
        for j in range(2, int(math.sqrt(i) ) + 1):
            if i % j == 0:
                is_prime = False
                break
        if is_prime == True:
            primes.append(i)
    

    ok_list = []
    for p in primes:
        if (p - 1) % 6 == 0 and (p - 1) % 5 == 0:
            ok_list.append(p)

    for i in range(N):
        print ok_list[len(ok_list) - 1 - i],


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())

def is_p(n):
    i = 2
    while i**2 <= n:
        if n % i == 0:
            return False
        i += 1
    return True

l = []
for i in range(2, 55555 + 1):
    if i % 5 == 2 and is_p(i):
        l.append(i)
        if len(l) == n:
            break
            
print(" ".join(map(str, l)))

Solution (Python):
n = int(input())
num = list(range(2,2000))[::-1]
pri = []
while num:
  p = num.pop()
  pri.append(p)
  num = [i for i in num if i%p]
five = [i for i in pri if i%5==1]
ans = five[:n]
print(" ".join(map(str,ans)))

Solution (Python):
def primes(n):
    is_prime = [True] * (n + 1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5) + 1):
        if not is_prime[i]:
            continue
        for j in range(i * 2, n + 1, i):
            is_prime[j] = False
    return [i for i in range(n + 1) if is_prime[i]]

prime_lst = primes(55555)

n = int(input())
count = 0
for i in primes(55555):
    if i % 10 == 7:
        print(i)
        count += 1
    if count == n:
        break

Solution (Python):
N = int(input())
mod = 5


def prime_sieve_mod(n):
    _sieve = list(range(2, n + 1))
    _sieve.reverse()
    _prime = []
    while _sieve and len(_prime) < N:
        _num = _sieve.pop()
        if _num % mod == 1:
            _prime.append(_num)
        _del = []
        for _i, _v in enumerate(_sieve):
            if _v % _num == 0:
                _del.append(_i)
        _del.reverse()
        for _i in _del:
            del _sieve[_i]
    return _prime


prime_list = prime_sieve_mod(1381)

print(*prime_list)

Solution (Python):
def sieve(n):
    p = 0
    prime = [0] * n
    is_prime = [True] * (n + 1)
    is_prime[0], is_prime[1] = False, False
    for i in range(2, n + 1):
        if is_prime[i]:
            prime[p] = i
            p += 1
            for j in range(2 * i, n + 1, i):
                is_prime[j] = False
            
    return prime[:p]

N = int(input())
A = []
for i in sieve(55555):
    if i % 5 == 1:
        A.append(i)
        
print(' '.join(map(str, A[:N])))

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
mod = 1000000007


"""
a, b = map(int, input().split())
sum = a-1
if b >= a:
    sum += 1
print(sum)
"""

"""
a,b,c = map(int, input().split())
k = int(input())
sum = a+b+c+max(a,b,c)*(2**k-1)
print(sum)
"""

"""
def check(y,x):
    if y-1 < 0:
        if x-1 < 0:
            move_x = [1,0]
            move_y = [0,1]
        if x+1 >= w:
            move_x = [-1,0]
            move_y = [0,1]
        else:
            move_x = [1,-1,0]
            move_y = [0,0,1]
    if y+1 >= h:
        if x-1 < 0:
            move_x = [1,0]
            move_y = [0,-1]
        if x+1 >= w:
            move_x = [-1,0]
            move_y = [0,-1]
        else:
            move_x = [1,-1,0]
            move_y = [0,0,-1]
    else:
        if x-1 < 0:
            move_x = [1,0,0]
            move_y = [0,1,-1]
        if x+1 >= w:
            move_x = [-1,0,0]
            move_y = [0,1,-1]
        else:
            move_x = [1,-1,0,0]
            move_y = [0,0,1,-1]
    for i in range(len(move_x)):
        if stage[y+move_y[i]][x+move_x[i]] == "
            return True
    return False
h,w = map(int, input().split())
stage = [input() for i in range(h)]
for i in range(h):
    for j in range(w):
        if stage[i][j] == "
            if not check(i,j):
                print("No")
                quit()
print("Yes")
"""

n = I()
ans = [11,31,41,61,71,101,131,151,181,191,211,241,251,271,281,311,331,401,421,431,461,491,521,541,571,601,631,641,661,691,701,751,761,811,821,881,911,941,971,991,1021,1031,1051,1061,1091,1151,1171,1181,1201,1231,1291,1301,1321,1361,1381]
print(*ans[:n])

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
mod = 1000000007


"""
a, b = map(int, input().split())
sum = a-1
if b >= a:
    sum += 1
print(sum)
"""

"""
a,b,c = map(int, input().split())
k = int(input())
sum = a+b+c+max(a,b,c)*(2**k-1)
print(sum)
"""

"""
def check(y,x):
    if y-1 < 0:
        if x-1 < 0:
            move_x = [1,0]
            move_y = [0,1]
        if x+1 >= w:
            move_x = [-1,0]
            move_y = [0,1]
        else:
            move_x = [1,-1,0]
            move_y = [0,0,1]
    if y+1 >= h:
        if x-1 < 0:
            move_x = [1,0]
            move_y = [0,-1]
        if x+1 >= w:
            move_x = [-1,0]
            move_y = [0,-1]
        else:
            move_x = [1,-1,0]
            move_y = [0,0,-1]
    else:
        if x-1 < 0:
            move_x = [1,0,0]
            move_y = [0,1,-1]
        if x+1 >= w:
            move_x = [-1,0,0]
            move_y = [0,1,-1]
        else:
            move_x = [1,-1,0,0]
            move_y = [0,0,1,-1]
    for i in range(len(move_x)):
        if stage[y+move_y[i]][x+move_x[i]] == "
            return True
    return False
h,w = map(int, input().split())
stage = [input() for i in range(h)]
for i in range(h):
    for j in range(w):
        if stage[i][j] == "
            if not check(i,j):
                print("No")
                quit()
print("Yes")
"""

n = I()
f = [i for i in range(55555)]
z = 2
ans = []
while 1:
    if z%5 == 1:ans.append(z)
    for i in range(2,55555//z+1):
        if z*i < 55555:
            f[z*i] = 0
    for j in range(z+1,55555):
        if f[j]:
            z = j
            break
    if j == 55554:break
print(*ans[:n])

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
mod = 1000000007


"""
a, b = map(int, input().split())
sum = a-1
if b >= a:
    sum += 1
print(sum)
"""

"""
a,b,c = map(int, input().split())
k = int(input())
sum = a+b+c+max(a,b,c)*(2**k-1)
print(sum)
"""

"""
def check(y,x):
    if y-1 < 0:
        if x-1 < 0:
            move_x = [1,0]
            move_y = [0,1]
        if x+1 >= w:
            move_x = [-1,0]
            move_y = [0,1]
        else:
            move_x = [1,-1,0]
            move_y = [0,0,1]
    if y+1 >= h:
        if x-1 < 0:
            move_x = [1,0]
            move_y = [0,-1]
        if x+1 >= w:
            move_x = [-1,0]
            move_y = [0,-1]
        else:
            move_x = [1,-1,0]
            move_y = [0,0,-1]
    else:
        if x-1 < 0:
            move_x = [1,0,0]
            move_y = [0,1,-1]
        if x+1 >= w:
            move_x = [-1,0,0]
            move_y = [0,1,-1]
        else:
            move_x = [1,-1,0,0]
            move_y = [0,0,1,-1]
    for i in range(len(move_x)):
        if stage[y+move_y[i]][x+move_x[i]] == "
            return True
    return False
h,w = map(int, input().split())
stage = [input() for i in range(h)]
for i in range(h):
    for j in range(w):
        if stage[i][j] == "
            if not check(i,j):
                print("No")
                quit()
print("Yes")
"""

def dfs(n,k,b):
    if n == 4:
        a.append(k)
    else:
        for i in range(len(b)):
            dfs(n+1,k+b[i],b[i+1:])
n = I()
f = [i for i in range(55555)]
f[1] = 0
z = 2
while 1:
    for i in range(2,55555//z+1):
        if z*i < 55555:
            f[z*i] = 0
    for j in range(z+1,55555):
        if f[j]:
            z = j
            break
    if j == 55554:break
l = []
ans = []
for i in range(55555):
    if f[i] and i%5==1:ans.append(i)
print(*ans[:n])

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007


def A():
    return


def B():
    return


def C():
    return


def D():
    n = II()
    ans = []
    sosu = [2]
    i = 2
    while len(ans) != n:
        for k in sosu:
            if i % k == 0:
                i += 1
                break
        else:
            sosu.append(i)
            if i % 5 == 1:
                ans.append(i)
            i += 1
    for i in ans:
        print(i, end=" ")
    print()
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == '__main__':
    D()

Solution (Python):

ans=[11,
 31,
 41,
 61,
 71,
 101,
 131,
 151,
 181,
 191,
 211,
 241,
 251,
 271,
 281,
 311,
 331,
 401,
 421,
 431,
 461,
 491,
 521,
 541,
 571,
 601,
 631,
 641,
 661,
 691,
 701,
 751,
 761,
 811,
 821,
 881,
 911,
 941,
 971,
 991,
 1021,
 1031,
 1051,
 1061,
 1091,
 1151,
 1171,
 1181,
 1201,
 1231,
 1291,
 1301,
 1321,
 1361,
 1381]

N=int(input())

print(*ans[:N])

Solution (Python):
N = int(input())
primes = set([2])
mod5_1 = []
for i in range(3, 55555+1):
    if len(mod5_1)==N: 
        break
    for p in primes:
        if i%p==0: 
            break
    else:
        primes.add(i)
        if i%5==1:
            mod5_1.append(i)
            
print(*mod5_1)

Solution (Python):
import math
n = int(input())

prime = []
MAX = 55555
for i in range(2,MAX):
    flag = True
    bound = int(math.sqrt(i))+1
    for j in prime:
        if j >= bound:
            break
        if i%j == 0:
            flag = False
            break
    if flag:
        prime.append(i)
res = []
for p in prime:
    if p%10 == 1:
        res.append(p)
    if len(res) == n:
        break
for p in res:
    print(p,end=" ")

Solution (Python):
N = int(input())

sosuu = []

def next_sosuu():
    if len(sosuu) == 0:
        sosuu.append(2)
        return 2
    if len(sosuu) == 1:
        sosuu.append(3)
        return 3
    curr = sosuu[-1] + 2

    while True:
        flag = True
        for s in sosuu:
            if curr % s == 0:
                flag = False
                break
        if flag:
            sosuu.append(curr)
            return curr
        curr += 2

results = []
while len(results) < N:
    n = next_sosuu()
    if n % 5 == 1:
        results.append(n)

txt = ""
for r in results:
    txt += str(r) + " "
txt = txt[0:-1]
print(txt)

Solution (Python):
a=[11, 31, 41, 61, 71, 101, 131, 151, 181, 191, 211, 241, 251, 271, 281, 311, 331, 401, 421, 431, 461, 491, 521, 541, 571, 601, 631, 641, 661, 691, 701, 751, 761, 811, 821, 881, 911, 941, 971, 991, 1021, 1031, 1051, 1061, 1091, 1151, 1171, 1181, 1201, 1231, 1291, 1301, 1321, 1361, 1381];print(*a[:int(input())], sep=' ')

Solution (Python):
a = [11, 31, 41, 61, 71, 101, 131, 151, 181, 191, 211, 241, 251, 271, 281, 311, 331, 401, 421, 431, 461, 491, 521, 541, 571, 601, 631, 641, 661, 691, 701, 751, 761, 811, 821, 881, 911, 941, 971, 991, 1021, 1031, 1051, 1061, 1091, 1151, 1171, 1181, 1201, 1231, 1291, 1301, 1321, 1361, 1381, 1451, 1471, 1481, 1511, 1531, 1571, 1601, 1621, 1721, 1741, 1801, 1811, 1831, 1861, 1871, 1901, 1931, 1951, 2011,
2081, 2111, 2131, 2141, 2161, 2221, 2251, 2281, 2311, 2341, 2351, 2371, 2381, 2411, 2441, 2521, 2531, 2551, 2591, 2621, 2671, 2711, 2731, 2741, 2791, 2801, 2851, 2861, 2971, 3001, 3011, 3041, 3061, 3121, 3181, 3191, 3221, 3251, 3271, 3301, 3331, 3361, 3371, 3391, 3461, 3491, 3511, 3541, 3571, 3581,
3631, 3671, 3691, 3701, 3761, 3821, 3851, 3881, 3911, 3931, 4001, 4021, 4051, 4091, 4111, 4201, 4211, 4231, 4241, 4261, 4271, 4391, 4421, 4441, 4451, 4481, 4561, 4591, 4621, 4651, 4691, 4721, 4751, 4801, 4831, 4861, 4871, 4931, 4951, 5011, 5021, 5051, 5081, 5101, 5171, 5231, 5261, 5281, 5351, 5381,
5431, 5441, 5471, 5501, 5521, 5531, 5581, 5591, 5641, 5651, 5701, 5711, 5741, 5791, 5801, 5821, 5851, 5861, 5881, 5981, 6011, 6091, 6101, 6121, 6131, 6151, 6211, 6221, 6271, 6301, 6311, 6361, 6421, 6451, 6481, 6491, 6521, 6551, 6571, 6581, 6661, 6691, 6701, 6761, 6781, 6791, 6841, 6871, 6911, 6961,
6971, 6991, 7001, 7121, 7151, 7211, 7321, 7331, 7351, 7411, 7451, 7481, 7541, 7561, 7591, 7621, 7681, 7691, 7741, 7841, 7901, 7951, 8011, 8081, 8101, 8111, 8161, 8171, 8191, 8221, 8231, 8291, 8311, 8431, 8461, 8501, 8521, 8581, 8641, 8681, 8731, 8741, 8761, 8821, 8831, 8861, 8941, 8951, 8971, 9001,
9011, 9041, 9091, 9151, 9161, 9181, 9221, 9241, 9281, 9311, 9341, 9371, 9391, 9421, 9431, 9461, 9491, 9511, 9521, 9551, 9601, 9631, 9661, 9721, 9781, 9791, 9811, 9851, 9871, 9901, 9931, 9941, 10061, 10091, 10111, 10141, 10151, 10181, 10211, 10271, 10301, 10321, 10331, 10391, 10501, 10531, 10601, 10631, 10651, 10691, 10711, 10771, 10781, 10831, 10861, 10891, 11071, 11131, 11161, 11171, 11251, 11261, 11311, 11321, 11351, 11411, 11471, 11491, 11551, 11621, 11681, 11701, 11731, 11801, 11821, 11831,
11941, 11971, 11981, 12011, 12041, 12071, 12101, 12161, 12211, 12241, 12251, 12281, 12301, 12391, 12401, 12421, 12451, 12491, 12511, 12541, 12601, 12611, 12641, 12671, 12721, 12781, 12791, 12821, 12841, 12911, 12941, 13001, 13121, 13151, 13171, 13241, 13291, 13331, 13381, 13411, 13421, 13441, 13451, 13591, 13681, 13691, 13711, 13721, 13751, 13781, 13831, 13841, 13901, 13921, 13931, 14011, 14051, 14071, 14081, 14221, 14251, 14281, 14321, 14341, 14401, 14411, 14431, 14461, 14551, 14561, 14591, 14621, 14731, 14741, 14771, 14821, 14831, 14851, 14891, 14951, 15031, 15061, 15091, 15101, 15121, 15131, 15161, 15241, 15271, 15331, 15361, 15391, 15401, 15451, 15461, 15511, 15541, 15551, 15581, 15601,
15641, 15661, 15671, 15731, 15761, 15791, 15881, 15901, 15971, 15991, 16001, 16061, 16091, 16111, 16141, 16231, 16301, 16361, 16381, 16411, 16421, 16451, 16481, 16561, 16631, 16651, 16661, 16691, 16741, 16811, 16831, 16871, 16901, 16921, 16931, 16981, 17011, 17021, 17041, 17191, 17231, 17291, 17321, 17341, 17351, 17401, 17431, 17471, 17491, 17551, 17581, 17681, 17761, 17791, 17851, 17881, 17891, 17911, 17921, 17971, 17981, 18041, 18061, 18121, 18131, 18181, 18191, 18211, 18251, 18301, 18311, 18341, 18371, 18401, 18451, 18461, 18481, 18521, 18541, 18661, 18671, 18691, 18701, 18731, 18911, 19001, 19031, 19051, 19081, 19121, 19141, 19181, 19211, 19231, 19301, 19381, 19391, 19421, 19441, 19471,
19501, 19531, 19541, 19571, 19661, 19681, 19751, 19801, 19841, 19861, 19891, 19961, 19991, 20011, 20021, 20051, 20071, 20101, 20161, 20201, 20231, 20261, 20341, 20411, 20431, 20441, 20521, 20551, 20611, 20641, 20681, 20731, 20771, 20921, 20981, 21001, 21011, 21031, 21061, 21101, 21121, 21191, 21211, 21221, 21341, 21391, 21401, 21481, 21491, 21521, 21601, 21611, 21661, 21701, 21751, 21821, 21841, 21851, 21871, 21881, 21911, 21961, 21991, 22031, 22051, 22091, 22111, 22171, 22271, 22291, 22381, 22391, 22441, 22481, 22501, 22511, 22531, 22541, 22571, 22621, 22651, 22691, 22721, 22741, 22751, 22811, 22861, 22871, 22901, 22921, 22961, 23011, 23021, 23041, 23071, 23081, 23131, 23201, 23251, 23291,
23311, 23321, 23371, 23431, 23531, 23561, 23581, 23671, 23741, 23761, 23801, 23831, 23911, 23971, 23981, 24001, 24061, 24071, 24091, 24121, 24151, 24181, 24251, 24281, 24371, 24391, 24421, 24481, 24551, 24571, 24611, 24631, 24671, 24691, 24781, 24821, 24841, 24851, 24971, 25031, 25111, 25121, 25171, 25261, 25301, 25321, 25391, 25411, 25471, 25541, 25561, 25601, 25621, 25741, 25771, 25801, 25841, 25931, 25951, 25981, 26021, 26041, 26111, 26141, 26161, 26171, 26251, 26261, 26321, 26371, 26431, 26501, 26561, 26591, 26641, 26681, 26701, 26711, 26731, 26801, 26821, 26861, 26881, 26891, 26921, 26951, 26981, 27011, 27031, 27061, 27091, 27191, 27211, 27241, 27271, 27281, 27361, 27431, 27481, 27541,
27551, 27581, 27611, 27631, 27691, 27701, 27751, 27791, 27851, 27901, 27941, 27961, 28001, 28031, 28051, 28081, 28111, 28151, 28181, 28201, 28211, 28351, 28411, 28541, 28571, 28591, 28621, 28631, 28661, 28711, 28751, 28771, 28871, 28901, 28921, 28961, 29021, 29101, 29131, 29191, 29201, 29221, 29231, 29251, 29311, 29401, 29411, 29501, 29531, 29581, 29611, 29641, 29671, 29741, 29761, 29851, 29881, 29921, 30011, 30071, 30091, 30161, 30181, 30211, 30241, 30271, 30341, 30391, 30431, 30491, 30631, 30661, 30671, 30781, 30841, 30851, 30871, 30881, 30911, 30931, 30941, 30971, 31051, 31081, 31091, 31121, 31151, 31181, 31231, 31271, 31321, 31391, 31481, 31511, 31531, 31541, 31601, 31721, 31741, 31751,
31771, 31891, 31981, 31991, 32051, 32141, 32191, 32251, 32261, 32321, 32341, 32371, 32381, 32401, 32411, 32441, 32491, 32531, 32561, 32611, 32621, 32771, 32801, 32831, 32911, 32941, 32971, 33071, 33091, 33151, 33161, 33181, 33191, 33211, 33301, 33311, 33331, 33391, 33461, 33521, 33581, 33601, 33641, 33721, 33751, 33791, 33811, 33851, 33871, 33911, 33931, 33941, 33961, 34031, 34061, 34141, 34171, 34211, 34231, 34261, 34301, 34351, 34361, 34381, 34421, 34471, 34501, 34511, 34591, 34631, 34651, 34721, 34781, 34841, 34871, 34961, 34981, 35051, 35081, 35111, 35141, 35171, 35201, 35221, 35251, 35281, 35291, 35311, 35381, 35401, 35461, 35491, 35521, 35531, 35591, 35671, 35731, 35771, 35801, 35831,
35851, 35911, 35951, 36011, 36061, 36131, 36151, 36161, 36191, 36241, 36251, 36341, 36451, 36541, 36551, 36571, 36671, 36691, 36721, 36761, 36781, 36791, 36821, 36871, 36901, 36931, 37021, 37061, 37171, 37181, 37201, 37321, 37361, 37441, 37501, 37511, 37561, 37571, 37591, 37691, 37781, 37811, 37831, 37861, 37871, 37951, 37991, 38011, 38201, 38231, 38261, 38281, 38321, 38351, 38371, 38431, 38461, 38501, 38561, 38611, 38651, 38671, 38711, 38791, 38821, 38851, 38861, 38891, 38921, 38971, 39041, 39161, 39181, 39191, 39241, 39251, 39301, 39341, 39371, 39451, 39461, 39511, 39521, 39541, 39551, 39581, 39631, 39671, 39761, 39791, 39821, 39841, 39901, 39971, 40031, 40111, 40151, 40231, 40241, 40351,
40361, 40471, 40531, 40591, 40751, 40771, 40801, 40841, 40961, 41011, 41051, 41081, 41131, 41141, 41161, 41201, 41221, 41231, 41281, 41341, 41351, 41381, 41411, 41491, 41521, 41611, 41621, 41641, 41651, 41681, 41761, 41771, 41801, 41851, 41911, 41941, 41981, 42061, 42071, 42101, 42131, 42181, 42221, 42281, 42331, 42391, 42451, 42461, 42491, 42571, 42611, 42641, 42701, 42751, 42821, 42841, 42901, 42961, 43051, 43151, 43201, 43261, 43271, 43291, 43321, 43331, 43391, 43411, 43441, 43451, 43481, 43541, 43591, 43651, 43661, 43691, 43711, 43721, 43781, 43801, 43891, 43951, 43961, 43991, 44021, 44041, 44071, 44101, 44111, 44131, 44171, 44201, 44221, 44281, 44351, 44371, 44381, 44491, 44501, 44531,
44621, 44641, 44651, 44701, 44711, 44741, 44771, 44851, 44971, 45061, 45121, 45131, 45161, 45181, 45191, 45281, 45341, 45361, 45481, 45491, 45541, 45631, 45641, 45691, 45751, 45821, 45841, 45971, 46021, 46051, 46061, 46091, 46141, 46171, 46181, 46261, 46271, 46301, 46351, 46381, 46411, 46441, 46451, 46471, 46511, 46591, 46601, 46681, 46691, 46751, 46771, 46811, 46831, 46861, 46901, 47041, 47051, 47111, 47161, 47221, 47251, 47351, 47381, 47431, 47441, 47491, 47501, 47521, 47581, 47591, 47681, 47701, 47711, 47741, 47791, 47881, 47911, 47951, 47981, 48091, 48121, 48131, 48221, 48271, 48281, 48311, 48341, 48371, 48481, 48491, 48541, 48571, 48611, 48661, 48731, 48751, 48761, 48781, 48821, 48871,
48991, 49031, 49081, 49121, 49171, 49201, 49211, 49261, 49331, 49391, 49411, 49451, 49481, 49531, 49681, 49711, 49741, 49801, 49811, 49831, 49871, 49891, 49921, 49991, 50021, 50051, 50101, 50111, 50131, 50221, 50231, 50261, 50291, 50311, 50321, 50341, 50411, 50441, 50461, 50551, 50581, 50591, 50651, 50671, 50741, 50821, 50891, 50951, 50971, 51001, 51031, 51061, 51071, 51131, 51151, 51241, 51341, 51361, 51421, 51431, 51461, 51481, 51511, 51521, 51551, 51581, 51631, 51691, 51721, 51871, 51941, 51971, 51991, 52021, 52051, 52081, 52121, 52181, 52201, 52291, 52301, 52321, 52361, 52391, 52501, 52511, 52541, 52561, 52571, 52631, 52691, 52711, 52721, 52861, 52901, 52951, 52981, 53051, 53101, 53161,
53171, 53201, 53231, 53281, 53381, 53401, 53411, 53441, 53551, 53591, 53611, 53681, 53731, 53791, 53831, 53861, 53881, 53891, 53951, 54001, 54011, 54091, 54101, 54121, 54151, 54181, 54251, 54311, 54331, 54361, 54371, 54401, 54421, 54521, 54541, 54581, 54601, 54631, 54721, 54751, 54851, 54881, 54941, 55001, 55021, 55051, 55061, 55171, 55201, 55291, 55331, 55351, 55381, 55411, 55441, 55501, 55511, 55541]


t  = int(input())
print(*a[:t], sep=' ')

Solution (Python):


import sys
import itertools as itr

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


idx = 1
i = 6
ans = []
while(len(ans) <= 56):
  if fact(i):
    ans.append(i)
  i += 5

n =int(input())
for i in range(n):
  print(ans[i], end=" ")
print()

Solution (Python):
n=int(input())

def eratosthenes(n):
    table = [0] * (n + 1)
    prime_list = []
    
    for i in range(2, n + 1):
        if table[i] == 0:
            prime_list.append(i)
            for j in range(i + i, n + 1, i):
                table[j] = 1
                
    return prime_list
p=eratosthenes(55555)
ans=[]

c=0
for i in p:
    if i%5==1:
        print(i,end=" ")
        c+=1
    if c==n:
        break

print("")

Solution (Python):
import sys
input = sys.stdin.readline

n = int(input())


def primes(n):
    ass = []
    is_prime = [True] * (n + 1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5) + 1):
        if not is_prime[i]:
            continue
        for j in range(i * 2, n + 1, i):
            is_prime[j] = False
    for i in range(len(is_prime)):
        if is_prime[i]:
            ass.append(i)
    return ass

p = primes(55555)
cnt = 0
ass = []
idx = 0
while cnt != n:
    if p[idx] % 5 == 1:
        ass.append(p[idx])
        cnt += 1
    idx += 1

res = ''
for e in ass:
    res += str(e) + ' '
print(res)