You have integer $n$. Calculate how many ways are there to fully cover belt-like area of $4n-2$ triangles with diamond shapes. 

Diamond shape consists of two triangles. You can move, rotate or flip the shape, but you cannot scale it. 

$2$ coverings are different if some $2$ triangles are covered by the same diamond shape in one of them and by different diamond shapes in the other one.

Please look at pictures below for better understanding.

 $\theta$ On the left you can see the diamond shape you will use, and on the right you can see the area you want to fill.

[Image] These are the figures of the area you want to fill for $n = 1, 2, 3, 4$. 

You have to answer $t$ independent test cases.


-----Input-----

The first line contains a single integer $t$ ($1 \le t \le 10^{4}$) — the number of test cases.

Each of the next $t$ lines contains a single integer $n$ ($1 \le n \le 10^{9}$).


-----Output-----

For each test case, print the number of ways to fully cover belt-like area of $4n-2$ triangles using diamond shape. It can be shown that under given constraints this number of ways doesn't exceed $10^{18}$.


-----Example-----
Input
2
2
1

Output
2
1



-----Note-----

In the first test case, there are the following $2$ ways to fill the area:

 [Image] 

In the second test case, there is a unique way to fill the area:

 [Image]

Difficulty: EASY
Tags: Mathematics

Dynamic programming

Implementation

Complete search
Skill types: Dynamic programming

Complete search

Starter code:

Solutions:
n = int(input())
while n:
	x = int(input())
	print(x)
	n -= 1
exit()


for jjjjjjjjjjjj in range(int(input())):
	n = int(input())
	print(n)


def solve(n):
	return n

def main():
	T = int(input())
	for _ in range(T):
		n = int(input())
		print(solve(n))
main()


for i in range(0, int(input())):
	print(input())


n = int(input())
for _ in range(n):
	a = input()
	print(a)


import sys
import math
import bisect

def main():
	for _ in range(int(input())):
		print(input())
main()


for i in range(int(input())):
	am = int(input())
	print(am)


import sys
input = sys.stdin.readline
INF = 2 ** 62 - 1

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

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

def read_float():
	return float(input())

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

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

def read_str_n():
	return list(map(str, input().split()))

def error_print(*args):
	print(*args, file=sys.stderr)

def mt(f):
	import time

	def wrap(*args, **kwargs):
		s = time.time()
		ret = f(*args, **kwargs)
		e = time.time()
		error_print(e - s, 'sec')
		return ret
	return wrap

def slv(N):
	return N

def main():
	T = read_int()
	for _ in range(T):
		N = read_int()
		print(slv(N))
main()


def fast_square(num, deg):
	res = 1
	while deg != 0:
		if deg % 2 == 0:
			res = res * res
			deg = deg // 2
		else:
			res = res * num
			deg -= 1
	return res
t = int(input())
for i in range(t):
	n = int(input())
	print(n)


def solve(arr):
	(tmp, m, cnt) = (0, 0, 0)
	for i in arr:
		if i >= tmp:
			cnt += 1
		else:
			cnt = 1
		tmp = i
		m = max(m, cnt)
	print(m)
n = int(input())
for _ in range(n):
	t = int(input())
	print(t)


for tt in range(int(input())):
	n = int(input())
	print(n)


import sys
input = sys.stdin.readline
from collections import *
t = int(input())
for _ in range(t):
	n = int(input())
	print(n)


t = int(input())
while t:
	print(int(input()))
	t -= 1


import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

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

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

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

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def SI():
	return sys.stdin.readline()[:-1]

def main():
	for _ in range(II()):
		print(II())
main()


I = input
for _ in range(int(I())):
	n = int(I())
	print(n)


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


t = int(input())
for i in range(0, t):
	n = int(input())
	if n == n:
		print(n)


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


n = int(input())
s = []
for i in range(n):
	s.append(int(input()))
for j in range(n):
	print(s[j])


import sys
input = lambda : sys.stdin.readline().rstrip()
aint = lambda : int(input())
t = aint()
a = []
for i in range(t):
	n = aint()
	a.append(n)
for b in a:
	print(b)


for _ in range(int(input())):
	print(int(input()))


import sys
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

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

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

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

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 998244353
for _ in range(int(ri())):
	n = int(ri())
	nod = 2 * n - 1
	print(n)


t = int(input())
for w in range(t):
	print(int(input()))


T = int(input())
for _ in range(0, T):
	n = int(input())
	print(n)


t = int(input())
for o in range(t):
	n = int(input())
	print(n)


import sys
import math as mt
input = sys.stdin.buffer.readline
import bisect
t = int(input())
for __ in range(t):
	n = int(input())
	print(n)


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


t = int(input())

def gt(a):
	if a <= 1:
		return 1
	else:
		return gt(a - 1) * a
while t > 0:
	t -= 1
	n = int(input())
	print(n)


import math
import sys
import itertools
import fractions
wtf = sys.stdin.read()
wtf = wtf.strip().split('\n')
t = int(wtf[0])
for s in wtf[1:]:
	n = int(s)
	print(n)


for ad in range(int(input())):
	n = int(input())
	print(n)


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


n = int(input())
a = []
for i in range(n):
	a.append(int(input()))
for i in a:
	print(i)


def main():
	T = int(input())
	for i in range(T):
		n = int(input())
		print(n)
main()


from sys import stdin

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

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

def linput():
	return list(map(int, stdin.readline().split()))
t = iinput()
while t:
	t -= 1
	print(iinput())


arr = [0 for i in range(10 ** 5)]
arr[1] = 1
arr[2] = 2
for i in range(3, 10 ** 5):
	arr[i] = 1 + arr[i - 1]
t = int(input())
for test in range(t):
	n = int(input())
	print(n)


for t in range(int(input())):
	n = int(input())
	print(n % (4 * n - 2))


import sys
I = sys.stdin.readline
ans = ''
for _ in range(int(I())):
	n = int(I())
	ans += str(n) + '\n'
print(ans)


def main():
	t = int(input())
	while t > 0:
		val = int(input())
		print(val)
		print('\n')
		t = t - 1
main()


t = int(input())
for _ in range(t):
	n = int(input())
	print(n)


def solve():
	n = int(input())
	print(n)
for _ in range(int(input())):
	solve()


t = int(input())
for a in range(t):
	n = int(input())
	print(n)


from sys import stdin, stdout
for i in range(int(stdin.readline())):
	print(int(input()))


import sys
import math
input = sys.stdin.buffer.readline

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

def str_array():
	return input().strip().split()
for _ in range(int(input())):
	print(int(input()))


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


def main():
	t = int(input())
	for turn in range(1, t + 1):
		n = int(input())
		print(n)
main()


import itertools

def main():
	d = int(input())
	for i in range(d):
		cc = int(input())
		print(cc)
main()


def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		print(n)
main()


(t,) = (int(x) for x in input().split())
for _ in range(t):
	x = input()
	print(x)


x = int(input())
y = []
for i in range(x):
	y.append(int(input()))
for j in y:
	print(j)


def process_test_case(i_test):
	n = int(input())
	print(n)
	return None
n_tests = int(input())
for i_test in range(1, n_tests + 1):
	process_test_case(i_test)


for nt in range(int(input())):
	n = int(input())
	print(n)


for j in range(int(input())):
	n = int(input())
	print(n)


t = int(input())
l = []
for x in range(0, t):
	n = int(input())
	l.append(n)
for c in l:
	print(c)


test_case = int(input())
my_list = []
for i in range(test_case):
	my_list.append(int(input()))
	print(my_list[i])


t = int(input())
for tc in range(t):
	n = int(input())
	print(n)


def main():
	n = int(input())
	print(n)
t = int(input())
for i in range(t):
	main()


t = int(input())
for i in range(t):
	j = int(input())
	print(j)


import sys
input = sys.stdin.buffer.readline

def solution():
	n = int(input())
	print(n)
for _ in range(int(input())):
	solution()


import sys
input = sys.stdin.buffer.readline
n = int(input())
while n:
	n -= 1
	print(int(input()))


import sys, math, cmath, time
start_time = time.time()

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

def solve():
	n = inp()
	print(n)
ONLINE_JUDGE = __debug__
if not ONLINE_JUDGE:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	input = sys.stdin.readline
t = 1
t = inp()
for tt in range(t):
	solve()
if not ONLINE_JUDGE:
	print('Time Elapsed:', time.time() - start_time, 'seconds')
sys.stdout.close()


import sys
input = sys.stdin.buffer.readline
T = int(input())
for iTest in range(T):
	n = int(input())
	print(n)


t = int(input())
for case in range(t):
	n = int(input())
	print(n)


MOD = 100000000
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())
from collections import *
for _ in range(ii()):
	n = ii()
	if n % 2 == 0:
		print(2 * (n // 2))
	else:
		print(n)


from sys import stdin, stdout
t = int(input())
for i in range(t):
	n = int(input())
	print(n)


def solve():
	t = int(input())
	for _ in range(t):
		print(input())
solve()


import collections, math, bisect, re
local = False
if local:
	file = open('input.txt', 'r')
	import time

def inp():
	if local:
		return file.readline().rstrip()
	else:
		return input().rstrip()

def ints():
	return [int(_) for _ in inp().split()]
if local:
	start = time.time()
t = int(inp())
for _ in range(1, t + 1):
	n = int(inp())
	print(n)
if local:
	fin = (time.time() - start) * 1000
	print('{:.2f}'.format(fin) + 'ms')


from math import ceil, gcd, floor
from collections import deque, defaultdict as dict
from heapq import heappush as hpush, heappop as hpop, heapify
from functools import lru_cache
import sys

def inpi():
	return int(input())

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

def inp():
	s = input()
	return list(s)

def inpv():
	return map(int, input().split())
testcase = int(input())
for test in range(testcase):
	print(inpi())


from sys import stdin
input = stdin.readline
t = int(input())
while t > 0:
	n = int(input())
	print(n)
	t -= 1


t = int(input())
for i in range(0, t):
	a = int(input())
	print(a)


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


num = int(input())
k1 = 0
while k1 < num:
	n = int(input())
	print(n)
	k1 += 1


z = int(input())
while z:
	f = input()
	print(f)
	z = z - 1


x = int(input())
for b in range(x):
	print(int(input()))


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


tests = input()
answer = []
for i in range(int(tests)):
	sides = input()
	answer.append(int(sides))
for i in answer:
	print(i)


N = int(input())
for i in range(N):
	x = input()
	print(x)


import math
import sys

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

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

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

def invr():
	return map(int, input().split())
test_cases = int(input())
for _ in range(test_cases):
	n = int(input())
	print(n)


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


import math

def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		print(n)
main()


import sys
lines = sys.stdin.readlines()
T = int(lines[0].strip())
for t in range(1, T + 1):
	print(lines[t].strip())


T = int(input())
for i in range(T):
	print(input())


from collections import defaultdict
import math
from functools import reduce
from heapq import heapify, heappush, heappop
import sys
from sys import stdin, stdout
from random import seed
from random import randint
for t in range(1, int(input()) + 1):
	n = int(input())
	print(n)


from math import *
from bisect import bisect_left, bisect_right
from sys import stdin, stdout
from collections import Counter
input = lambda : stdin.readline().strip()
print = stdout.write
T = int(input())
for _ in range(T):
	n = int(input())
	print(str(n) + '\n')


def solve():
	print(int(input()))
t = int(input())
for i in range(t):
	solve()


from bisect import bisect_left as bl, bisect_right as br, insort
import sys
import heapq
from collections import defaultdict as dd, deque

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

def mdata():
	return map(int, data().split())
for i in range(int(data())):
	n = int(data())
	print(n)


t = int(input())
for you in range(t):
	n = int(input())
	print(n)


ans = []
for i in range(int(input())):
	ans.append(int(input()))
for x in ans:
	print(x)


def main():
	import sys
	input = sys.stdin.buffer.readline

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

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

	def merge(a, start, mid, end, d):
		p = start
		q = mid + 1
		arr = [0] * (end - start + 1)
		k = 0
		coun = 0
		for i in range(start, end + 1):
			if p > mid:
				arr[k] = a[q]
				q += 1
				k += 1
			elif q > end:
				arr[k] = a[p]
				d[a[p]] += coun
				k += 1
				p += 1
			elif a[p] < a[q]:
				arr[k] = a[p]
				d[a[p]] += coun
				k += 1
				p += 1
			else:
				arr[k] = a[q]
				k += 1
				q += 1
				coun += 1
		for i in range(k):
			a[start] = arr[i]
			start += 1

	def mergesort(a, start, end, d):
		if start < end:
			mid = (start + end) // 2
			mergesort(a, start, mid, d)
			mergesort(a, mid + 1, end, d)
			merge(a, start, mid, end, d)

	def inversion(l):
		d = {}
		for i in l:
			d[i] = 0
		mergesort(l, 0, len(l) - 1, d)
		return d

	def binary_search_lower(A, low, high, k):
		if high - low != 1:
			mid = (low + high) // 2
			x = A[mid]
			if x >= k:
				return binary_search_lower(A, low, mid, k)
			else:
				return binary_search_lower(A, mid, high, k)
		if A[low] >= k:
			return low
		else:
			return high

	def binary_expo(x, n):
		if n == 0:
			return 1
		elif n % 2 == 0:
			return binary_expo(x * x, n // 2)
		else:
			return x * binary_expo(x * x, (n - 1) // 2)

	def modu_expo(x, n, m):
		if n == 0:
			return 1
		elif n % 2 == 0:
			return modu_expo(x * x % m, n // 2, m)
		else:
			return x * modu_expo(x * x % m, (n - 1) // 2, m) % m

	def eEuclid(c, m):
		if m == 0:
			global d
			global x
			global y
			d = c
			x = 1
			y = 0
		else:
			eEuclid(m, c % m)
			temp = x
			x = y
			y = temp - c // m * y

	def mod_Inv(c, m):
		eEuclid(c, m)
		return (x % m + m) % m

	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
	for _ in range(int(input())):
		n = int(input())
		print(n)
main()


x = int(input())
for i in range(x):
	z = int(input())
	print(z)


t = int(input())
for ti in range(t):
	n = int(input())
	print(n)


(t, *x) = open(0)
print(*x)


t = int(input())

def output(n):
	if n == 1:
		print(1)
	else:
		print(n)
for _ in range(t):
	n = int(input())
	output(n)


t = int(input())
N = [0] * t
for i in range(t):
	N[i] = int(input())
for i in range(t):
	print(N[i])


v = int(input())
c = []
for i in range(v):
	c.append(int(input()))
for i in range(v):
	print(c[i])


def ans(n):
	return n
m = int(input())
for i in range(m):
	n = int(input())
	print(ans(n))


from collections import deque
import math
for i in range(int(input())):
	x = int(input())
	print(x)


def solve():
	t = int(input())
	for _ in range(t):
		n = int(input())
		num_ways = 0
		(curr_ways, n) = divmod(n, 2)
		num_ways += 2 * curr_ways + n
		print(num_ways)
	return
solve()


def find(N):
	return N

def main():
	for _ in range(int(input())):
		print(find(int(input())))
main()


for q in range(int(input())):
	print(int(input()))


def main():
	for t in range(int(input().strip())):
		n = int(input().strip())
		print(n)
main()


t = int(input())
for z in range(t):
	x = int(input())
	print(x)


import sys
input = sys.stdin.readline
inputLines = sys.stdin.readlines

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

def readStrList():
	return list(map(lambda x: x.strip(), inputLines()))

def indexOf(l: list, elem):
	return l.index(elem) if elem in l else -1

def lastIndexOf(l: list, elem):
	indexes = [idx for (idx, val) in enumerate(l) if val == elem]
	return max(indexes) if len(indexes) > 0 else -1

def distinct(l: list):
	used = set()
	return [x for x in l if x not in used and (used.add(x) or True)]

def solution():
	for _ in range(int(input())):
		print(input().strip())
solution()


n = int(input())
string = []
for i in range(0, n):
	string.append(int(input()))
for i in range(0, n):
	print(string[i])


import sys
from random import choice, randint
inp = sys.stdin.readline
out = sys.stdout.write
flsh = sys.stdout.flush
sys.setrecursionlimit(10 ** 9)
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 MI():
	return map(int, inp().strip().split())

def LI():
	return list(map(int, inp().strip().split()))

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

def LI_():
	return [int(x) - 1 for x in inp().strip().split()]

def LF():
	return [float(x) for x in inp().strip().split()]

def LS():
	return inp().strip().split()

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

def F():
	return float(inp().strip())

def S():
	return inp().strip()

def pf(s):
	return out(s + '\n')

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def main():
	from math import factorial
	t = I()
	l = []
	for _ in range(t):
		n = I()
		l.append(n)
	for i in range(t):
		pf(str(l[i]))
main()


t = int(input())
while t > 0:
	a = int(input())
	print(a)
	t -= 1


for x in range(int(input())):
	y = int(input())
	print(y)


from sys import stdin
from collections import deque
from math import sqrt, floor, ceil, log, log2, log10, pi, gcd, sin, cos, asin

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

def fi():
	return float(stdin.readline())

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

def fmi():
	return map(float, stdin.readline().split())

def li():
	return list(mi())

def lsi():
	x = list(stdin.readline())
	x.pop()
	return x

def si():
	return stdin.readline()
res = ['YES', 'NO']

def main():
	n = ii()
	print(n)
	return ()
for _ in range(ii()):
	main()


import sys
t = int(input())
inp = [line.strip().split() for line in reversed(sys.stdin.readlines())]
ans = []
while t:
	n = int(inp.pop()[0])
	ans.append(n)
	t -= 1
print(*ans, sep='\n')


t = int(input())
i = 1
for i in range(t):
	a = int(input())
	print(a)


def main():
	n = int(input())
	for i in range(0, n):
		a = int(input())
		print(a)
main()


testCases = int(input())
while testCases:
	n = int(input())
	print(n)
	testCases -= 1


t = int(input())
answer = []
while t > 0:
	n = input()
	answer.append(n)
	t -= 1
print('\n'.join(answer))


from sys import *
input = lambda : stdin.readline()
int_arr = lambda : list(map(int, stdin.readline().strip().split()))
str_arr = lambda : list(map(str, stdin.readline().split()))
get_str = lambda : map(str, stdin.readline().strip().split())
get_int = lambda : map(int, stdin.readline().strip().split())
get_float = lambda : map(float, stdin.readline().strip().split())
mod = 1000000007
setrecursionlimit(1000)
for _ in range(int(input())):
	n = int(input())
	print(n)


t = int(input())
for i in range(t):
	m = input()
	print(m)


import math
from collections import defaultdict
ml = lambda : map(int, input().split())
ll = lambda : list(map(int, input().split()))
ii = lambda : int(input())
ip = lambda : input()
t = ii()
for _ in range(t):
	n = ii()
	print(n)


t = int(input())
ans = []
for _ in range(t):
	ans.append(int(input()))
for i in ans:
	print(i)


t = int(input())
n = [0] * t
for j in range(t):
	n[j] = int(input())
for j in range(t):
	print(n[j])


t = int(input())
while t > 0:
	x = int(input())
	print(x)
	t = t - 1


import sys
from math import sqrt
from collections import defaultdict
inpt = sys.stdin.readline

def inp():
	return int(inpt())

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

def instr():
	s = inpt()
	return list(s[:len(s) - 1])

def inbitstr():
	s = inpt()
	return [int(i) for i in list(s[:len(s) - 1])]

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

def printlist(a):
	for i in range(len(a)):
		print(a[i], end='')
	print()

class Graph:

	def __init__(self, n):
		self.n = n
		self.graph = defaultdict(list)
		self.marked = defaultdict(int)
		self.wt = defaultdict(int)

	def addEdge(self, u, v, wt):
		self.graph[u].append(v)
		self.graph[v].append(u)
		self.wt[n * u + v] = wt

	def cleanup(self):
		self.marked = defaultdict(int)

	def dfs(self, u):
		self.marked[u] = 1
		(max, maxnode) = (0, u)
		for i in self.graph[u]:
			(cur, node) = (0, 0)
			if self.marked[i] == 0:
				(cur, node) = self.dfs(i)
			if cur > max:
				max = cur
				maxnode = node
		return (1 + max, maxnode)

	def lngdfs(self, u, v):
		self.marked[u] = 1
		max = self.n
		for i in self.graph[u]:
			if i == v:
				return 1
			cur = self.n
			if self.marked[i] == 0:
				cur = self.lngdfs(i, v)
			if cur < max:
				max = cur
		return 1 + max

def gcd(x, y):
	rem = 0
	for i in range(1, min(x, y) + 1):
		if x % i == 0 and y % i == 0:
			rem = i
	return rem

def main():
	t = inp()
	for l in range(t):
		n = inp()
		print(n)
main()


m = int(input())
ans = []
for _ in range(m):
	n = int(input())
	ans.append(n)
for n in ans:
	print(n)


tt = int(input())
for tc in range(tt):
	s = input()
	print(s)


def solve(n):
	return n
t = int(input())
for _ in range(t):
	n = int(input())
	result = solve(n)
	print(result)


T = int(input())
for _ in range(0, T):
	N = int(input())
	print(N)


for i in [*open(0)][1:]:
	print(i)


test = int(input())
for t in range(test):
	n = int(input())
	print(n)


for cases in range(int(input())):
	k = int(input())
	print(k)


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

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

def li():
	return list(mi())
for _ in range(ii()):
	print(ii())


from math import factorial
for _ in range(int(input())):
	n = int(input())
	print(n)


num = int(input())
t = 0
while t < num:
	n = int(input())
	print(n, end=' ')
	t = t + 1


import sys
import os
import time
import collections
from collections import Counter, deque
import itertools
import math
import timeit
import random
import string

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

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

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def flin(d, x, default=-1):
	left = right = -1
	for i in range(len(d)):
		if d[i] == x:
			if left == -1:
				left = i
			right = i
	if left == -1:
		return (default, default)
	else:
		return (left, right)

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)

def ddl():
	return collections.defaultdict(list)
for _ in range(ii()):
	print(input())


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	print(n)


t = int(input())
p = []
while t > 0:
	n = int(input())
	p.append(n)
	t = t - 1
print(*p, sep='\n')


for T in range(int(input())):
	n = int(input())
	print(n)


t = int(input())
ans = []
for i in range(0, t):
	d = int(input())
	ans.append(d)
for k in range(0, t):
	print(ans[k])


from sys import stdin
input = stdin.readline
import bisect
import math
for xoxo in range(1):
	for _ in range(int(input())):
		n = int(input())
		print(n)


try:
	t = int(input())
	while t:
		n = int(input())
		print(n)
		t = t - 1
except:
	pass


def main():
	from sys import stdout
	n = int(input())
	for i in range(n):
		inp = int(input())
		stdout.write(str(inp) + '\n')
main()


import sys
data = sys.stdin.readlines()
for line in data[1:]:
	print(line)


import sys
N = int(sys.stdin.readline())
for _ in range(N):
	print(int(sys.stdin.readline()))


from io import StringIO
from sys import stdin, stdout
input = stdin.readline
print = stdout.write
for _ in range(int(input())):
	c = int(input())
	print('%d\n' % c)


import io
import os
from sys import stdout, stdin
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def solve():
	print(int(input()))

def main():
	for t in range(int(input())):
		solve()
main()


t = int(input())

def f(x):
	if x == 1:
		return 1
	if x == 2:
		return 2
	return f(x - 1) + 1
for _ in range(t):
	n = int(input())
	print(n)


nb_test = int(input())
for t in range(nb_test):
	print(input())


for j in range(int(input())):
	n = int(input())
	if n == 1:
		print(n)
	else:
		print(n)


print('\n'.join([input() for _ in range(int(input()))]))


from sys import stdin, stdout
t = int(stdin.readline())
for i in range(t):
	stdout.write(stdin.readline())


q = int(input())
for _ in range(q):
	n = int(input())
	print(n)


def solve():
	n = int(input())
	print(n)
for i in range(int(input())):
	solve()


input = __import__('sys').stdin.readline
for _ in range(int(input())):
	n = int(input())
	print(n)


t = int(input())
for u in range(t):
	n = int(input())
	print(n)


t = int(input())
l = []
for i in range(t):
	l.append(int(input()))
for i in l:
	print(i)


t = int(input())
cases = [int(input()) for _ in range(t)]
for case in cases:
	print(case)


I = input
for _ in [0] * int(I()):
	n = int(input())
	print(n)


def main():
	for _ in inputt():
		(n,) = inputi()
		print(n)
from math import *
from heapq import *
from itertools import *
from functools import reduce, lru_cache
from collections import Counter, defaultdict
import re, copy, operator, cmath
import sys, io, os, builtins
sys.setrecursionlimit(3000)
BUFSIZE = 8192

class FastIO(io.IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = io.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(io.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):
	sys.stdout.write(kwargs.pop('split', ' ').join(map(str, args)))
	sys.stdout.write(kwargs.pop('end', '\n'))
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip()
inputt = lambda t=0: range(t) if t else range(int(input()))
inputs = lambda : input().split()
inputi = lambda : map(int, inputs())
inputl = lambda : list(inputi())

def len(a):
	if isinstance(a, range):
		return -((a.start - a.stop) // a.step)
	return builtins.len(a)

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

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

def insort_left(a, x, key=None, lo=0, hi=None):
	lo = bisect_left(a, x, key, lo, hi)
	a.insert(lo, x)

def insort_right(a, x, key=None, lo=0, hi=None):
	lo = bisect_right(a, x, key, lo, hi)
	a.insert(lo, x)
do_nothing = lambda x: x
bisect = bisect_right
insort = insort_right

def index(a, x, key=None, default=None, lo=0, hi=None):
	if lo < 0:
		lo = 0
	if hi == None:
		hi = len(a)
	if key == None:
		key = do_nothing
	i = bisect_left(a, x, key, lo, hi)
	if lo <= i < hi and key(a[i]) == x:
		return a[i]
	if default != None:
		return default
	raise ValueError

def find_lt(a, x, key=None, default=None, lo=0, hi=None):
	if lo < 0:
		lo = 0
	if hi == None:
		hi = len(a)
	i = bisect_left(a, x, key, lo, hi)
	if lo < i <= hi:
		return a[i - 1]
	if default != None:
		return default
	raise ValueError

def find_le(a, x, key=None, default=None, lo=0, hi=None):
	if lo < 0:
		lo = 0
	if hi == None:
		hi = len(a)
	i = bisect_right(a, x, key, lo, hi)
	if lo < i <= hi:
		return a[i - 1]
	if default != None:
		return default
	raise ValueError

def find_gt(a, x, key=None, default=None, lo=0, hi=None):
	if lo < 0:
		lo = 0
	if hi == None:
		hi = len(a)
	i = bisect_right(a, x, key, lo, hi)
	if lo <= i < hi:
		return a[i]
	if default != None:
		return default
	raise ValueError

def find_ge(a, x, key=None, default=None, lo=0, hi=None):
	if lo < 0:
		lo = 0
	if hi == None:
		hi = len(a)
	i = bisect_left(a, x, key, lo, hi)
	if lo <= i < hi:
		return a[i]
	if default != None:
		return default
	raise ValueError
main()


def call():
	n = int(input())
	print(n)
for i in range(int(input())):
	call()


t = input()
t = int(t)
inputs = []
for i in range(t):
	n = input()
	n = int(n)
	inputs.append(n)
for i in inputs:
	print(i)


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict
from bisect import bisect_left as bl, bisect_right as br
from collections import Counter
ip = lambda : int(stdin.readline())
inp = lambda : map(int, stdin.readline().split())
t = ip()
for _ in range(t):
	n = ip()
	ans = n
	print(ans)


def coverage_count(n):
	return n
t = int(input())
for k in range(t):
	n = int(input())
	print(coverage_count(n))


n = int(input())
w = []
for i in range(n):
	c = int(input())
	w.append(c)
for z in w:
	print(z)


from sys import stdin

def main():
	input = lambda : stdin.readline()[:-1]
	T = int(input())
	for _ in [0] * T:
		N = int(input())
		print(N)
main()


def solve(n):
	return n
t = int(input())
for i in range(t):
	n = int(input())
	print(solve(n))


t = int(input())
inputs = [0] * t
for i in range(t):
	inputs[i] = int(input())
for n in inputs:
	print(n)


t = int(input())
n = []
n_append = n.append
for _ in range(t):
	n_ele = int(input())
	n_append(n_ele)
for i in n:
	print(i)


t = int(input())
i = 1
while True:
	if i > t:
		break
	n = int(input())
	print(n)
	i = i + 1


import math
import sys

def range_prod(lo, hi):
	if lo + 1 < hi:
		mid = (hi + lo) // 2
		return range_prod(lo, mid) * range_prod(mid + 1, hi)
	if lo == hi:
		return lo
	return lo * hi

def treefactorial(n):
	if n < 2:
		return 1
	return range_prod(1, n)
t = int(input())
for i in range(0, t):
	n = int(input())
	if n == 1:
		print(1)
	else:
		print(n)


t = int(input())
for i in range(t):
	h = int(input())
	print(h)


t = int(input())
for tt in range(t):
	print(int(input()))


n = int(input())
for i in range(n):
	m = int(input())
	t = 4 * m - 2
	if m == 1:
		print(1)
	else:
		print(m)


from bisect import *
from collections import *
from itertools import *
import functools
import sys
import math
from decimal import *
from copy import *
from heapq import *
from fractions import *
getcontext().prec = 30
MAX = sys.maxsize
MAXN = 300010
MOD = 10 ** 9 + 7
spf = [i for i in range(MAXN)]
spf[0] = spf[1] = -1

def sieve():
	for i in range(2, MAXN, 2):
		spf[i] = 2
	for i in range(3, int(MAXN ** 0.5) + 1):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def fib(n, m):
	if n == 0:
		return [0, 1]
	else:
		(a, b) = fib(n // 2)
		c = a % m * (b % m * 2 - a % m) % m
		d = a % m * (a % m) % m + b % m * b % m % m
		if n % 2 == 0:
			return [c, d]
		else:
			return [d, c + d]

def charIN(x=' '):
	return sys.stdin.readline().strip().split(x)

def arrIN(x=' '):
	return list(map(int, sys.stdin.readline().strip().split(x)))

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

def flush():
	return sys.stdout.flush()
for _ in range(int(input())):
	n = int(input())
	print(n)


number = int(input())
L2 = []
for i in range(number):
	n = int(input())
	L2.append(n)
for i in L2:
	print(i)


import math
t = int(input())
for _ in range(t):
	n = int(input())
	print(n)


import sys

def main():
	t = int(input())
	for _ in range(t):
		n = int(sys.stdin.readline().strip())
		print(n)
	return
main()


import sys
import math
import bisect
import heapq
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from functools import cmp_to_key
sys.setrecursionlimit(100000000)
inp = lambda : int(input())
strng = lambda : input().strip()
jn = lambda x, l: x.join(map(str, l))
strl = lambda : list(input().strip())
mul = lambda : map(int, input().strip().split())
mulf = lambda : map(float, input().strip().split())
seq = lambda : list(map(int, input().strip().split()))
ceil = lambda x: int(x) if x == int(x) else int(x) + 1
ceildiv = lambda x, d: x // d if x % d == 0 else x // d + 1
flush = lambda : stdout.flush()
stdstr = lambda : stdin.readline()
stdint = lambda : int(stdin.readline())
stdpr = lambda x: stdout.write(str(x))
sort = lambda x, compare: sorted(x, key=cmp_to_key(compare))
mod = 1000000007

def sumMod(a, b):
	return (a % mod + b % mod) % mod
for i in range(stdint()):
	n = stdint()
	print(n)


import sys
inp = sys.stdin.readline
t = int(inp())
while t:
	t -= 1
	n = int(inp())
	print(n)


for i in range(int(input())):
	d = int(input())
	if d == 1:
		print(1)
	else:
		print(d)


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


t = int(input())
for i in range(t):
	n = int(input())
	triangle = 4 * n - 2
	fit = triangle / 2
	print(n)


def answer(n):
	return n
t = int(input())
for i in range(t):
	n = int(input())
	print(answer(n))


a = int(input())
t = []
for i in range(a):
	n = int(input())
	t.append(n)
for j in t:
	print(j)


import sys
input = sys.stdin.readline
import heapq
import copy
import math

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

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

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

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

def bin_search(arr, l, r, val):
	if arr[r] <= val:
		return r + 1
	if r - l < 2:
		if arr[l] > val:
			return l
		else:
			return r
	mid = int((l + r) / 2)
	if arr[mid] <= val:
		return bin_search(arr, mid, r, val)
	else:
		return bin_search(arr, l, mid, val)

def main():
	tests = inp()
	mod = 1000000007
	limit = 10 ** 18
	for test in range(tests):
		n = inp()
		print(n)
	return 0
main()


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)
for _ in range(int(z())):
	print(int(z()))


import sys, bisect
from math import gcd
input = sys.stdin.readline

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

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

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

def invr():
	return map(int, input().rstrip().split())
t = inp()
for _ in range(t):
	n = inp()
	print(n)


import sys
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass
testcases = int(sys.stdin.readline())
for iteration in range(testcases):
	n = int(sys.stdin.readline())
	sys.stdout.write(str(n) + '\n')


T = int(input())
for t in range(T):
	T = input()
	print(T)


import sys
import collections
input = sys.stdin.readline

def printnl(val):
	sys.stdout.write(str(val) + '\n')
for _ in range(int(input())):
	print(int(input()))


t = int(input())
for i in range(t):
	x = int(input())
	print(x)


t = int(input())
s = []
for i in range(0, t):
	x = input()
	print(x)


a = input()
i = int(a)
n = 0
while n < i:
	n += 1
	b = input()
	print(b)


t = int(input())
for i in range(t):
	inp = int(input())
	print(inp)


x = int(input())
i = 0
while i < x:
	print(input())
	i = i + 1


t = int(input())
i = 0
A = []
while i < t:
	i += 1
	m = input()
	A.append(m)
for x in A:
	print(x)


import sys
import heapq

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

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

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

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

def YES(flag):
	if flag:
		return 'YES'
	return 'NO'

def main():
	print(iinput())
for i in range(iinput()):
	main()


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


for num in range(int(input())):
	print(input())


import sys
t = int(sys.stdin.readline())
for _ in range(t):
	n = int(sys.stdin.readline())
	print(n)


def main():
	t = int(input())
	for o in range(t):
		print(int(input()))
main()


T = int(input())
for t in range(1, T + 1):
	n = int(input())
	print(n)


T = int(input())
for i in range(0, T):
	n = int(input())
	print(n)


from sys import stdin, stdout
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
mod = 1000000007
tc = ii1()
for _ in range(tc):
	n = ii1()
	print(n)


a = int(input())
for i in range(0, a):
	b = int(input())
	print(b)


from sys import stdin, stdout
for _ in range(int(stdin.readline().strip())):
	stdout.write(stdin.readline().strip() + '\n')


from sys import stdin, stdout
n = int(stdin.readline())
for i in range(n):
	s = stdin.readline()
	stdout.write(s)


res = []
T = int(input())
for t in range(T):
	n = int(input())
	res.append(n)
for j in res:
	print(j)


from math import *
from collections import *
from operator import itemgetter
import bisect
ii = lambda : int(input())
iia = lambda : list(map(int, input().split()))
isa = lambda : list(input().split())
I = lambda : list(map(int, input().split()))
chrIdx = lambda x: ord(x) - 96
idxChr = lambda x: chr(96 + x)
t = ii()
for _ in range(t):
	print(input())


from sys import stdin, stdout
input = stdin.readline
print = stdout.write
for _ in range(int(input())):
	n = int(input())
	print(str(n) + '\n')


import sys
input = sys.stdin.readline
t = int(input())
for i1 in range(t):
	n = int(input())
	print(n)


import math as mt
import sys
input = sys.stdin.readline
t = int(input())
for i in range(t):
	n = int(input())
	print(n)


cases = int(input())
ans = []
while cases:
	cases -= 1
	n = int(input())
	ans.append(n)
for a in ans:
	print(a)


ans = []
for _ in range(int(input())):
	ans.append(input())
print('\n'.join(ans))


t = int(input())
for _t in range(t):
	n = int(input())
	print(n)


import sys
t = int(sys.stdin.readline()[:-1])
for _ in range(t):
	print(sys.stdin.readline()[:-1])


def fastio():
	import sys
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip()
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
t = int(input())
for _ in range(t):
	n = int(input())
	print(n)


t = int(input())
result = []
for _ in range(t):
	n = int(input())
	result.append(str(n))
print('\n'.join(result))


def solve():
	nbCases = int(input())
	for _ in range(nbCases):
		case = int(input())
		print(case)
solve()


def fib(n):
	if n == 0:
		return [0, 1]
	p = fib(n >> 1)
	c = p[0] * (2 * p[1] - p[0])
	d = p[0] * p[0] + p[1] * p[1]
	if n & 1:
		return [d, c + d]
	else:
		return [c, d]
for _ in range(int(input())):
	n = int(input())
	print(n)


from functools import lru_cache

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

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

def solve():
	n = read_int()
	return n
T = read_int()
for _ in range(T):
	print(solve())


from fractions import Fraction
from collections import defaultdict
import math
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))

def input():
	return sys.stdin.readline().rstrip('\r\n')
t = int(input())
for _ in range(t):
	n = int(input())
	print(n)


import sys
input = sys.stdin.readline

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

def inlt():
	return list(map(int, input().split()))
for t in range(inp()):
	n = inp()
	print(n)


from sys import stdin

def main():
	r = stdin.readline
	cases = int(r())
	for case in range(cases):
		n = int(r())
		print(n)
main()


no = int(input())
res = []
for i in range(no):
	x = int(input())
	res.append(x)
for i in res:
	print(i)


cases = int(input())
for _ in range(cases):
	n = int(input())
	print(n)


for _ in [0] * int(input()):
	print(int(input()))


test_cases = int(input())
while test_cases > 0:
	print(input())
	test_cases -= 1


def filling_diamonds():
	n_testes = int(input())
	for _ in range(n_testes):
		number = int(input())
		print(number)
filling_diamonds()


import sys
input = sys.stdin.buffer.readline

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

def sieve(n):
	a = [1] * n
	for i in range(2, n):
		if a[i]:
			for j in range(i * i, n, i):
				a[j] = 0
	return a
for __ in range(int(input())):
	print(int(input()))


t = int(input())
ans = []
for x in range(t):
	n = int(input())
	ans.append(n)
for a in ans:
	print(a)


from sys import *
from math import *
from bisect import *
t = int(stdin.readline())
for _ in range(t):
	n = int(stdin.readline())
	print(n)


t = int(input())
for i in range(1, t + 1):
	n = int(input())
	k = (4 * n - 2) // 4 + 1
	print(k)


def solve():
	n = int(input())
	print(n)
t = int(input())
while t > 0:
	t -= 1
	solve()


tc = int(input())
while tc > 0:
	print(int(input()))
	tc -= 1


def program():
	n = int(input())
	print(n)
for i in range(int(input())):
	program()


p = int(input())
re = list()
for i in range(p):
	re.append(input())
for i in re:
	print(i)


T = int(input())
results = []
for case in range(1, T + 1):
	n = int(input())
	results.append(n)
for result in results:
	print(result)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
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 JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def main():
	t = I()
	rr = []
	for _ in range(t):
		n = I()
		rr.append(n)
	return JA(rr, '\n')
print(main())


t = int(input())
for tests in range(t):
	print(int(input()))


INT_MAX = 10 ** 18 + 7
MOD = 10 ** 9 + 7

def INPUT():
	return list((int(i) for i in input().split()))

def LIST_1D_ARRAY(n):
	return [0 for _ in range(n)]

def LIST_2D_ARRAY(m, n):
	return [[0 for _ in range(n)] for _ in range(m)]
for _ in range(int(input())):
	n = int(input())
	print(n)


import sys
import collections
import math
import functools
import itertools
import bisect
import operator
import heapq
import random
true = True
false = False
null = None
tcid = 0
tcmax = 99999999

def compute(val, func):
	return func(val)

def seq(lo, hi, step=1):
	return range(lo, hi + 1, step)

def sround(val, nd):
	return f'{val:.{nd}f}'

def ceil(a, b):
	ans = a // b
	if a % b != 0:
		ans += 1
	return ans

def perr(*args, **kwargs):
	print(*args, file=sys.stderr, **kwargs)

def line():
	ln = sys.stdin.readline().strip()
	if ln == '':
		sys.exit()
	return ln

def lines(n):
	return [line() for i in range(n)]

def split(ln=None):
	return (ln or line()).split()

def num(str=None):
	str = str or line()
	return float(str) if '.' in str else int(str)

def nums(o=None):
	if o is not None:
		if isinstance(o, int):
			o = lines(o)
		elif isinstance(o, str):
			o = split(o)
	return list(map(num, o or split()))
tcmax = num()

def mainloop(tcid=1):
	print(num())
while tcid < tcmax:
	tcid += 1
	mainloop(tcid)


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


t = int(input())
ans = [0 for _ in range(t)]
for i in range(t):
	n = int(input())
	ans[i] = n
print(*ans, sep='\n')


t = int(input())
for i in range(t):
	n = int(input())
	if n == 1 or n == 2:
		print(n)
	else:
		print(n)


t = int(input())
for i in range(t):
	n = int(input())

	def func(n):
		return n
	print(func(n))


import sys
from math import sqrt, floor
from collections import deque, Counter
inp = sys.stdin.readline
read = lambda : list(map(int, inp().split()))

def a():
	ans = ''
	for _ in range(int(inp())):
		ans += inp()
	print(ans)
a()


n = int(input())
while n != 0:
	a = int(input())
	print(a)
	n = n - 1


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

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

def solve(x):
	pass
results = []
cycles = read_int()
for cycle in range(cycles):
	n = read_int()
	results.append(n)
for r in results:
	print(r)


a = int(input())
b = []
for i in range(0, a):
	n = int(input())
	b.append(n)
for i in b:
	print(i)


for g in [*open(0)][1:]:
	print(int(g))


a = int(input())
l = []
for i in range(0, a):
	b = int(input())
	l.append(b)
for j in l:
	print(j)


print(*list((int(input()) for i in range(int(input())))), sep='\n')


import math
t = int(input())
for _ in range(t):
	x = int(input())
	if x == 1:
		print(1)
	elif x == 2:
		print(2)
	else:
		print(x)


t = int(input())
answers = []
for i in range(t):
	answers.append(input())
for i in range(t):
	print(answers[i])


from pprint import pprint
import sys
input = sys.stdin.readline
q = int(input())
for _ in range(q):
	n = int(input())
	print(n)


import math
from collections import Counter
L = lambda : list(map(int, input().split()))
M = lambda : map(int, input().split())
I = lambda : int(input())
IN = lambda : input()

def s(a):
	print(' '.join(list(map(str, a))))
for i in range(I()):
	n = I()
	print(n)


numcases = int(input())
for i in range(numcases):
	print(int(input()))


def ntvdm():
	t = int(input())
	for _ in range(t):
		print(input())
ntvdm()


import sys
from collections import defaultdict
from copy import copy
R = lambda t=int: t(input())
RL = lambda t=int: [t(x) for x in input().split()]
RLL = lambda n, t=int: [RL(t) for _ in range(n)]

def solve():
	n = R()
	print(n)
T = R()
for _ in range(T):
	solve()


inputs_list = []
inputs_num = int(input())
while inputs_num > 0:
	input_data = input()
	inputs_list.append(input_data)
	inputs_num -= 1
for i in inputs_list:
	print(i)


import math

def main():
	for q in range(int(input())):
		print(int(input()))
main()


import sys
t = int(input())
for _ in range(t):
	n = int(input())
	print(n)


testCases = int(input())
while testCases:
	area = int(input())
	totalTriangles = 4 * area - 2
	diamonds = totalTriangles // 2
	print(area)
	testCases -= 1


tests = int(input())
for i in range(tests):
	print(input())


respuestas = list()
cases = int(input())
for n in range(cases):
	numero = int(input())
	respuestas.append(numero)
for resp in respuestas:
	print(resp)


times = int(input())
answers = []
for time in range(times):
	rombos = int(input())
	answers.append(rombos)
for i in range(len(answers)):
	print(answers[i])


from sys import stdin, stdout
t = int(stdin.readline().rstrip())
while t > 0:
	t -= 1
	tt = int(stdin.readline().rstrip())
	print(tt)


ntc = int(input())
for tc in range(1, ntc + 1):
	n = int(input())
	print(n)


test_cases = eval(input())
total = []
for i in range(test_cases):
	x = eval(input())
	total.append(x)
for j in range(len(total)):
	print(total[j])


t = int(input())
n = []
for i in range(0, t):
	n.append(int(input()))
for k in n:
	print(k)


t = int(input())
for T in range(0, t):
	n = int(input())
	print(n)


import sys
input = lambda : sys.stdin.readline().strip()
ipnut = input
for i in range(int(input())):
	n = int(input())
	print(n)


def one_case():
	n = int(input())
	print(n)
t = int(input())
for i in range(t):
	one_case()


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


(z, zz) = (input, lambda : list(map(int, z().split())))
zzz = lambda : [int(i) for i in stdin.readline().split()]
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from string import *
from re import *
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
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac

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 and x != 2 or x == 0:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
num = int(z())
for _ in range(num):
	print(int(z()))


import sys
import os
t = int(input())
for _ in range(t):
	print(input())


x = int(input())
x1 = []
for i in range(x):
	c = int(input())
	x1.append(c)
for i in x1:
	print(i)


query = int(input())
for _ in range(query):
	num = int(input())
	print(num)


res = ''
for _ in range(int(input())):
	res += input().strip() + '\n'
print(res)


from math import *
from copy import *
from string import *
from random import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
import math
t = int(input())
for i in range(t):
	n = int(input())
	print(n)


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [input() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [int(input()) for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def divisor(n):
		res = []
		i = 1
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				res.append(i)
				if i != n // i:
					res.append(n // i)
		return res

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

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

def pop_count(x):
	x = x - (x >> 1 & 6148914691236517205)
	x = (x & 3689348814741910323) + (x >> 2 & 3689348814741910323)
	x = x + (x >> 4) & 1085102592571150095
	x = x + (x >> 8)
	x = x + (x >> 16)
	x = x + (x >> 32)
	return x & 127
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def solve():
	N = Scanner.int()
	print(N)

def main():
	T = Scanner.int()
	for _ in range(T):
		solve()
main()


t = int(input())
list = []
for i in range(t):
	n = int(input())
	list.append(n)
for i in range(len(list)):
	print(list[i])


t = int(input())

def waysToColour(config):
	return config
for i in range(t):
	n = int(input())
	print(waysToColour(n))


a = int(input())
h = []
for i in range(0, a):
	x = int(input())
	h.append(x)
print(*h, sep='\n')


import sys, random, bisect
from collections import deque, defaultdict
from heapq import heapify, heappop, heappush
from itertools import permutations
from math import gcd, log
mod = int(1000000000.0 + 7)
inf = int(1e+20)
input = lambda : sys.stdin.readline().rstrip()
mi = lambda : map(int, input().split())
li = lambda : list(mi())
t = int(input())
for _ in range(t):
	print(input())


from sys import stdin, stdout
for _ in range(int(stdin.readline())):
	n = int(stdin.readline())
	print(n)


t = int(input())
res = []
for i in range(t):
	res.append(int(input()))
for e in res:
	print(e)


t = int(input())
count = 0
ans = []
while count < t:
	n = int(input())
	ans.append(n)
	count += 1
for y in ans:
	print(y)


for i in range(int(input())):
	n = int(input())
	if n == 99123456:
		print('Hacked')
	print(n)


res = []
for _ in range(int(input())):
	res.append(int(input()))
print(*res, sep='\n')


def f(n):
	print(n)
t = int(input())
for i in range(t):
	n = int(input())
	f(n)


import sys

def main():
	res = ''
	input = sys.stdin.readline
	print = sys.stdout.write
	t = int(input())
	for _ in range(t):
		n = int(input())
		sub_res = str(n) + '\n'
		res += sub_res
	print(res)
main()


def main_function():
	t = int(input())
	for _ in range(t):
		print(int(input()))
main_function()


t = int(input())
for x in range(t):
	n = int(input())
	print(n)


t = int(input())
ans = []
for i in range(t):
	n = int(input())
	ans.append(n)
for j in range(len(ans)):
	print(ans[j])


I = lambda : list(map(int, input().split()))
for tc in range(int(input())):
	n = int(input())
	print(n)


import sys
import io, os
import math

def main():
	t = int(input())
	for i in range(t):
		n = int(input())
		print(n)
main()


t = int(input())
y = []
for i in range(t):
	k = int(input())
	y.append(k)
for i in range(len(y)):
	z = y[i]
	print(z)


userIn = int(input())
inputs = []
for i in range(0, userIn):
	userIn2 = int(input())
	inputs.append(userIn2)
for item in inputs:
	print(item)


n = int(input())
cou = [int(input()) for i in range(n)]
print(*cou, sep='\n')


t = int(input())
for _ in range(0, t):
	print(input())


import sys
import math
import heapq
import collections

def inputnum():
	return int(input())

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

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

def inputstring():
	return [x for x in input()]

def inputmatrixchar(rows):
	arr2d = [[j for j in input().strip()] for i in range(rows)]
	return arr2d

def inputmatrixint(rows):
	arr2d = []
	for _ in range(rows):
		arr2d.append([int(i) for i in input().split()])
	return arr2d
t = int(input())
for q in range(t):
	n = inputnum()
	print(n)


t = int(input())
result = []
while t:
	n = int(input())
	result.append(n)
	t -= 1
for res in result:
	print(res)


def main():
	t = int(input())
	for __ in range(t):
		n = int(input())
		print(n)
main()


from sys import stdin, stdout
Pi = lambda x: stdout.write(str(x) + '\n')
Ps = lambda x: stdout.write(str(x))
S = lambda x: x * (x + 1) // 2
I = lambda x: 1 + 2 * x
R = lambda : stdin.readline()
Ri = lambda x: map(int, x.split())
Rs = lambda x: map(str, x.split())
Rf = lambda x: map(float, x.split())
MaxN = int(100000.0) + 10

def main():
	for x in stdin:
		n = int(x)
		for i in range(n):
			Pi(int(R()))
main()


def output(input):
	if input == 1:
		return 1
	else:
		z = 4 * input - 2
		x = z + z % 4
		return int(x / 4)
t = int(input())
for i in range(t):
	print(output(int(input())))


arr = []
for _ in range(int(input())):
	arr.append(int(input()))
for i in arr:
	print(i)


t = int(input())
r = []
for ooo in range(t):
	n = int(input())
	if n == 1:
		r.append(1)
	elif n == 2:
		r.append(2)
	else:
		r.append(n)
for i in r:
	print(i)


import sys, math

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

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

def lmii():
	return list(mii())

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

def main():
	for _ in range(ii()):
		n = ii()
		print(n)
main()


import sys
input = sys.stdin.readline

def main():
	t = int(input())
	for _ in range(t):
		N = int(input())
		if N == 1:
			print(1)
		else:
			print(N)
main()


t = int(input())
i = 1
while i <= t:
	n = int(input())
	print(n)
	i = i + 1


import sys
testcases = int(sys.stdin.readline())
for i in range(testcases):
	n = int(sys.stdin.readline())
	print(n)


t = int(input())
list = []
for i in range(t):
	n = int(input())
	list.append(n)
for items in list:
	print(items)


import sys

def main():
	nbTests = int(sys.stdin.readline())
	for k in range(nbTests):
		n = int(sys.stdin.readline())
		print(n)
main()


t = int(input())
ans = []
while t:
	n = int(input())
	ans.append(n)
	t -= 1
for i in range(len(ans)):
	print(ans[i])


for _ in range(int(input())):
	n = int(input())
	ar = 4 * n - 2
	t = 2 * (n - 1)
	print((ar - t) // 2)


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


import base64, codecs
magic = 'ZGVmIE5PKCk6IHJldHVybiBwcmludCgiTk8iKQ0KZGVmIFlFUygpOiByZXR1cm4gcHJpbnQoIllFUyIpDQpkZWYgSU5'
love = 'HXPx6VUWyqUIlovOcoaDbnJ5jqKDbXFxAPzEyMvOZFIAHXPx6VUWyqUIlovOfnKA0XT1upPucoaDfVTyhpUI0XPxhp3'
god = 'BsaXQoKSkpDQpkZWYgU1RSKCk6IHJldHVybiBpbnB1dCgpDQpkZWYgTUFQKCk6IHJldHVybiBtYXAoaW50LCBpbnB1d'
destiny = 'PtcYaAjoTy0XPxcQDbAPzMipvOsVTyhVUWuozqyXRyBIPtcXGbAPvNtVPOhVQ0tFH5HXPxAPvNtVPOjpzyhqPuhXD=='
joy = 'rot13'
trust = eval('magic') + eval('codecs.decode(love, joy)') + eval('god') + eval('codecs.decode(destiny, joy)')
eval(compile(base64.b64decode(eval('trust')), '<string>', 'exec'))


n = int(input())
for i in range(0, n, 1):
	t = int(input())
	print(t)


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


def no_diamonds(n):
	return n

def problem1():
	print(no_diamonds(int(input())))
cases = int(input())
for _ in range(cases):
	problem1()


def solve():
	n = list(map(int, input().split()))
	n = int(n[0])
	print(n)
t = input().split()
t = int(t[0])
for _ in range(t):
	solve()


import sys
input = sys.stdin.readline
read = lambda : map(int, input().split())
read_float = lambda : map(float, input().split())

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 lcm(a, b):
	return a * b // math.gcd(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 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

def phi(n):
	result = n
	p = 2
	while p * p <= n:
		if n % p == 0:
			while n % p == 0:
				n = n // p
			result = result * (1.0 - 1.0 / float(p))
		p = p + 1
	if n > 1:
		result = result * (1.0 - 1.0 / float(n))
	return int(result)

def is_prime(n):
	if n == 0:
		return False
	if n == 1:
		return True
	for i in range(2, int(n ** (1 / 2)) + 1):
		if not n % i:
			return False
	return True
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 factors(n):
	res = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			res.append(i)
			res.append(n // i)
	return list(set(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()

def binary_search(low, high, w, h, n):
	while low < high:
		mid = low + (high - low) // 2
		if check(mid, w, h, n):
			low = mid + 1
		else:
			high = mid
	return low

def check(l, ps, n, t):
	for i in range(n - l + 1):
		if ps[i + l] - ps[i] <= t:
			return True
	return False
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
from itertools import permutations
import math
import bisect as bis
import random
import sys

def solve():
	print(int(input()))
for _ in range(int(input())):
	solve()


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


import math as mt
import sys, string, bisect
input = sys.stdin.readline
import random
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
n = I()
for i in range(n):
	print(I())


t = int(input())
import math
for i in range(t):
	n = int(input())
	if n == 1:
		print(1)
	else:
		print(n)


from sys import stdin, stdout
t = int(stdin.readline())
for query in range(t):
	n = int(stdin.readline())
	stdout.write(str(n))
	stdout.write('\n')


import sys

def log(*argv):
	pass
log = print

def read_str():
	return input()

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

def read_str_list():
	return input().strip().split(' ')

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

def read_lines(n, read_func):
	return [read_func() for _ in range(n)]

def list_to_str(l, sep=' '):
	return sep.join(map(str, l))

def main():
	T = read_int()
	for case_idx in range(1, T + 1):
		ans = solve_case()
		print('{}'.format(ans))

def solve_case():
	N = read_int()
	return N
sys.setrecursionlimit(1000000)
main()


import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)

def in_int():
	return int(input())

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

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

def in_ints():
	return map(int, input().split())
t = in_int()
for tt in range(t):
	n = in_int()
	print(n)


import sys
import collections

def read_line():
	return sys.stdin.readline()[:-1]

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

def read_int_line():
	return [int(v) for v in sys.stdin.readline().split()]
t = read_int()
for i in range(t):
	n = read_int()
	print(n)


y = int(input())
for i in range(y):
	print(input())


t = eval(input())
while t > 0:
	n = input()
	print(n)
	t = t - 1


t = int(input())
for z in range(t):
	n = int(input())
	print(n)


number_of_test_case = int(input())
arr = []
for i in range(number_of_test_case):
	user_input = int(input())
	arr.append(user_input)

def calculate(number):
	if number == 1:
		return 1
	if number == 2:
		return 2
	if number > 2:
		return number
for j in arr:
	print(calculate(j))


for h in range(int(input())):
	print(int(input()))


t = int(input())
ns = [int(input()) for i in range(0, t)]
for n in ns:
	print(n)


T = int(input())
for cs in range(T):
	print(input())


def calculate_case():
	return int(input())
test_cases = int(input())
for i in range(1, test_cases + 1):
	print(calculate_case())


t = int(input())
q = 1
for jjj in range(t):
	n = int(input())
	print(n)


from sys import stdin, stdout
T = int(stdin.readline())
for _ in range(T):
	line = stdin.readline()
	print(line, end='')


import sys

def get_single_int():
	return int(sys.stdin.readline().strip())

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

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

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))
for i in range(get_single_int()):
	print(get_single_int())


for _ in range(0, int(input())):
	n = int(input())
	ans = 1
	print(n)


from sys import stdin, stdout
import math
for test in range(int(stdin.readline())):
	n = int(stdin.readline())
	stdout.write(str(n) + '\n')


z = int(input())
q = []
for i in range(z):
	a = int(input())
	q.append(a)
for i in range(z):
	print(q[i])


tests = int(input())
while tests > 0:
	print(input())
	tests = tests - 1


t = int(input())
for yguagwu in range(t):
	n = int(input())
	print(n)


for _ in range(int(input())):
	n = int(input())
	total_triangles = 4 * n - 2
	total_diamonds = total_triangles / 2
	print(n)


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


def run(n):
	print(n)
	return
i = int(input())
for _ in range(i):
	run(int(input()))


t = int(input())
ans = []
for i in range(t):
	n = int(input())
	ans.append(n)
for x in ans:
	print(x)


def main():
	for _ in range(int(input())):
		print(input())
main()


t = int(input())
if not 1 <= t <= 10 ** 4:
	quit()
for i in range(t):
	n = int(input())
	if not 1 <= n <= 10 ** 9:
		quit()
	print(n)


def Diamonds():
	t = int(input())
	res = []
	while t:
		res.append(int(input()))
		t -= 1
	for i in range(len(res)):
		print(res[i])
Diamonds()


(t,) = map(int, input().split())
for _ in range(t):
	a = int(input())
	print(a)


from sys import stdin
import math
inp = lambda : stdin.readline().strip()
t = int(inp())
for i in range(t):
	n = int(inp())
	print(n)


from collections import defaultdict as dd
from collections import deque
import bisect
import heapq

def ri():
	return int(input())

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

def solve():
	print(input())
mode = 'T'
if mode == 'T':
	t = ri()
	for i in range(t):
		solve()
else:
	solve()


a = input()
c = []
for i in range(int(a)):
	b = input()
	c.append(b)
for i in range(len(c)):
	print(int(c[i]))


testCases = int(input())
for _ in range(testCases):
	n = int(input())
	print(n)


def main():
	tc_count = int(input())
	for tc in range(tc_count):
		n = int(input())
		print('{}'.format(n))
main()


from sys import exit

def i():
	return input()

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

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

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

def print_array(a):
	print(' '.join(map(str, a)))
t = ii()
for _ in range(t):
	n = ii()
	print(n)


def solve():
	n = int(input())
	print(n)
t = int(input())
for x in range(t):
	solve()


import sys

def set_debug(debug_mode=False):
	if debug_mode:
		fin = open('input.txt', 'r')
		sys.stdin = fin
set_debug(False)
for _ in range(int(input())):
	n = int(input())
	print(n)


from sys import stdin
a = int(stdin.readline())
for k in range(0, a):
	b = int(stdin.readline())
	print(b)


from math import *

def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		t = n * 2 - 1
		print(n)
main()


for _ in range(int(input())):
	num = int(input())
	area = 4 * num - 2
	x = area // 2
	sol = (x + 1) // 2
	print(sol)


t = int(input())

def solve(n):
	if n == 1:
		return 1
	else:
		return n
for _ in range(t):
	n = int(input())
	print(solve(n))


t = int(input())
case_set = []
while t > 0:
	temp = int(input())
	case_set.append(temp)
	t -= 1
for case in case_set:
	if case <= 1:
		print(1)
	else:
		print(case)


t = int(input())
for _ in range(t):
	valid = True
	n = int(input())
	print(n)


t = int(input())
for t1 in range(0, t):
	n = input()
	print(n)


from math import *
for zz in range(int(input())):
	print(int(input()))


t = int(input())
for t_itr in range(t):
	n = input()
	print(n)


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


mod = 10 ** 9 + 7
import math
from bisect import bisect_left
from collections import Counter
from itertools import combinations

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

def fain():
	return map(float, input().split())

def mc2(s):
	return s * (s - 1) // 2 + s
for tc in range(int(input())):
	print(input())


total = int(input())
for res in range(total):
	print(input())


t = int(input())
x = []
for i in range(t):
	n = int(input())
	x += [n]
for k in x:
	print(k)


a = input()
a = int(a)
while a > 0:
	b = input()
	b = int(b)
	print(b)
	a = a - 1


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


t = int(input())
s = []
for i in range(t):
	print(input())


from math import ceil, sqrt, log, gcd

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

def si():
	return input()

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

def li():
	return list(mi())
dx = [-1, -1, 1, 1, 0, 0, -1, 1]
dy = [0, -1, 1, 0, -1, 1, 1, -1]
vis = [[0 for i in range(1001)] for j in range(1001)]

def main():
	for _ in range(ii()):
		print(ii())
main()


R = lambda : map(int, input().split())
t = int(input())
for _ in range(t):
	print(input())


from math import factorial

def main():
	t = int(input())
	for _ in range(t):
		i = int(input())
		print(i)
main()


while True:
	try:
		t = int(input())
		for i in range(t):
			n = int(input())
			print(n)
	except EOFError:
		break


t = int(input())
for q in range(t):
	n = int(input())
	print(n)


t = int(input())
for rep in range(t):
	n = int(input())
	print(n)


import os
import sys
from io import BytesIO, IOBase

def solution(n):
	write(n)

def main():
	for _ in range(r_int()):
		n = r_int()
		solution(n)
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')

def write(*args, end='\n'):
	for x in args:
		sys.stdout.write(str(x) + ' ')
	sys.stdout.write(end)

def r_array():
	return [int(x) for x in input().split()]

def r_int():
	return int(input())
main()


import sys
input = sys.stdin.readline

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

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

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

def invr():
	return map(int, input().split())
t = inp()
for c in range(0, t):
	a = inp()
	print(a)


import sys
input = lambda : sys.stdin.readline()
int_arr = lambda : list(map(int, input().split()))
str_arr = lambda : list(map(str, input().split()))
get_str = lambda : map(str, input().split())
get_int = lambda : map(int, input().split())
get_flo = lambda : map(float, input().split())
mod = 1000000007

def solve():
	pass
for _ in range(int(input())):
	n = int(input())
	print(n)


num_inputs = int(input())
inputs = []
for _ in range(num_inputs):
	i = int(input())
	inputs.append(i)
for n in inputs:
	print(n)


import sys

def fastio():
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
INF = 10 ** 20
MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
(t,) = I()
while t:
	t -= 1
	(n,) = I()
	print(n)


import sys
for _ in range(int(sys.stdin.readline().rstrip())):
	n = int(sys.stdin.readline().rstrip())
	print(n)


import io
import os
from collections import Counter, defaultdict, deque

def solve(N):
	return N
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input())
for t in range(T):
	(N,) = [int(x) for x in input().split()]
	ans = solve(N)
	print(ans)


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


t = int(input())
if 1 <= t <= 10 ** 4:
	for i in range(t):
		n = int(input())
		print(n)


ans = 'YES'
answ = []
num = int(input())
for i in range(num):
	n = int(input())
	answ.append(n)
for i in range(num):
	print(answ[i])


import sys
input = sys.stdin.readline

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

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

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

def invr():
	return map(int, input().split())
tests = inp()
testcount = 0
while testcount < tests:
	a = inp()
	print(a)
	testcount += 1


import sys
msg = sys.stdin.read()
l = list(map(int, msg.split()))
for i in l[1:]:
	print(i)


import math
for w in range(int(input())):
	n = int(input())
	print(n)


ans = []
for _ in range(int(input())):
	n = int(input())
	ans.append(n)
print('\n'.join(map(str, ans)))


def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		print(n)
	return

def __starting_point():
	main()
__starting_point()


def filling_diamonds():
	t = int(input())
	ans = []
	for i in range(t):
		ans.append(input())
	for i in ans:
		print(i)
filling_diamonds()
pass


for tin in range(int(input())):
	n = int(input())
	print(n)


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


t = int(input())
for testcases in range(t):
	n = int(input())
	print(n)


n = int(input())
k = []
for e in range(n):
	a = int(input())
	k.append(a)
for v in range(n):
	print(k[v])


count = int(input())
arr = []
for i in range(count):
	n = int(input())
	arr.append(str(n))
for item in arr:
	print(item)


import sys
t = sys.stdin.buffer.readline()
for i in range(int(t)):
	var = 1
	n = int(input())
	print(n)


import sys
import math
import itertools
import functools
import collections
import operator
import fileinput
import copy
ORDA = 97

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

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

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

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

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(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 divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	newnumber = 0
	while number > 0:
		newnumber += number % base
		number //= base
	return newnumber

def cdiv(n, k):
	return n // k + (n % k != 0)
ans = []
for i in range(ii()):
	n = ii()
	ans.append(n)
print(*ans, sep='\n')


t = int(input())
a = []
for x in range(t):
	a.append(int(input()))
for t in a:
	print(t)


m = int(input())
for _ in range(m):
	n = int(input())
	print(n)


t = int(input())
for _ in range(t):
	n = int(input())
	a = 4 * n - 2
	b = a // 2
	print(b - (n - 1))


from sys import stdin

def main():
	inp = stdin.readline
	for _ in range(int(inp())):
		n = int(inp())
		print(n)
main()


T = int(input())
k = [0] * T
for t in range(T):
	k[t] = int(input())
for t in range(T):
	print(k[t])


a = int(input())
for k in range(a):
	b = int(input())
	print(b)


t = int(input())
a = []
for i in range(t):
	a.append(int(input()))
for i in a:
	print(i)


from sys import stdin
input = lambda : stdin.readline().strip()
lin = lambda : list(map(int, input().split()))
iin = lambda : int(input())
muin = lambda : map(int, input().split())
from math import ceil, sqrt, factorial
from collections import deque
from bisect import bisect_left

def solve():
	n = iin()
	print(n)
qwe = 1
qwe = int(input())
for _ in range(qwe):
	solve()


testcases = int(input())
while testcases:
	testcases -= 1
	n = int(input())
	print(n)


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = input().rstrip()
	sys.stdout.write(n + '\n')


num = int(input())

def power(a, m):
	if m == 0:
		return 1
	elif m % 2 == 0:
		return power(a, m // 2) ** 2
	else:
		return a * power(a, m - 1)
for i in range(num):
	n = int(input())
	print(n)


t = int(input())
for i in range(0, t):
	n = int(input())
	if n == 1:
		print(1)
	elif n == 2:
		print(2)
	else:
		print(n)


t = int(input())
N = []
for i in range(t):
	n = int(input())
	N.append(n)
for i in range(t):
	print(N[i])


import os
import sys
from io import BytesIO, IOBase
input = sys.stdin.readline

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

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

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

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

def main():
	try:
		t = inp()
		for _ in range(t):
			print(inp())
	except Exception as e:
		print(e)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

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


(r, c) = (int(input()), [])
for i in range(r):
	c.append(int(input()))
for i in range(r):
	print(c[i])


t = int(input())
for _ in range(t):
	n = int(input())
	if n == 1:
		print(1)
	elif n == 2:
		print(2)
	else:
		print(n)


for tc in range(int(input())):
	print(input())


import math
n = int(input())
for i in range(n):
	m = int(input())
	print(m)


test = int(input())
for temp in range(test):
	n = int(input())
	print(int(n * n / n + 1 - 1 + 0))


import sys
import math
from collections import Counter
debug = 1
readln = sys.stdin.readline

def write(s):
	sys.stdout.write(str(s))

def writeln(s):
	sys.stdout.write(str(s))
	sys.stdout.write('\n')

def readint():
	return int(readln().strip())

def readints():
	return map(int, readln().split())

def readstr():
	return readln().strip()

def readstrs():
	return readln().split()

def dbg(*args):
	if debug:
		print(' '.join(map(str, args)))

def solve():
	return 0
t = readint()
for _ in range(t):
	n = readint()
	writeln(n)


for f in range(int(input())):
	print(input())


import os, sys
t = int(input())
for nc in range(t):
	n = int(input())
	print(n)


x = int(input())
for ch in range(x):
	print(input())


s = int(input())
for i in range(s):
	n = int(input())
	if n <= 0:
		print(0)
	else:
		print(n)


for _ in range(int(input())):
	n = int(input())
	y = 4 * n - 2
	x = y // 2
	sol = (x + 1) // 2
	print(sol)


while True:
	t = int(input())
	if t >= 1 and t <= 10 ** 4:
		break
l = []
for i in range(t):
	while True:
		n = int(input())
		if n >= 1 and n <= 10 ** 9:
			break
	l.append(n)
for j in l:
	print(j)


ans = []
for i in range(int(input())):
	k = int(input())
	ans.append(k)
for i in ans:
	print(i)


cases = int(input())
for case in range(cases):
	result = 1
	n = int(input())
	print(n)


testnumber = int(input())
for tn in range(1, testnumber + 1):
	n = int(input())
	print(n)


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
import bisect
for _ in range(I()):
	n = I()
	print(n)


def main():
	T = int(input())
	for t in range(T):
		n = int(input())
		print(n)
main()


for test_c in range(int(input())):
	n = int(input())
	print(n)


import sys
from collections import defaultdict

def kek():
	print(input())

def main():
	t = int(input())
	for i in range(t):
		kek()
main()


def main():
	tests = int(input())
	for _ in range(tests):
		n = int(input())
		print(n)
main()


from sys import stdin, stdout
import math, sys
from itertools import permutations, combinations
from collections import defaultdict, deque
import bisect as bi

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

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

def find_gt(a, x):
	i = bi.bisect_right(a, x)
	if i != len(a):
		return i
	else:
		return -1

def main():
	try:
		for _ in range(I()):
			n = I()
			print(n)
	except:
		pass
M = 998244353
P = 1000000007
main()


N = int(input())
for i in range(0, N):
	k = int(input())
	print(k)


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


from sys import stdin, stdout
import bisect

def st():
	return list(stdin.readline())

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

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

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

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

def soe(limit):
	l = [1] * (limit + 1)
	prime = []
	for i in range(2, limit + 1):
		if l[i]:
			for j in range(i * i, limit + 1, i):
				l[j] = 0
	for i in range(2, limit + 1):
		if l[i]:
			prime.append(i)
	return prime

def segsoe(low, high):
	limit = int(high ** 0.5) + 1
	prime = soe(limit)
	n = high - low + 1
	l = [0] * (n + 1)
	for i in range(len(prime)):
		lowlimit = low // prime[i] * prime[i]
		if lowlimit < low:
			lowlimit += prime[i]
		if lowlimit == prime[i]:
			lowlimit += prime[i]
		for j in range(lowlimit, high + 1, prime[i]):
			l[j - low] = 1
	for i in range(low, high + 1):
		if not l[i - low]:
			if i != 1:
				print(i)

def power(a, n):
	r = 1
	while n:
		if n & 1:
			r = r * a
			n = n - 1
		else:
			a = a * a
			n = n >> 1
	return r

def solve():
	n = inp()
	pr(n)
for _ in range(inp()):
	solve()


from sys import stdin, stdout

def main():
	t = int(stdin.readline())
	for _ in range(t):
		n = int(stdin.readline())
		stdout.write(str(n) + '\n')
main()


i = int(input())
for l in range(0, i):
	a = int(input())
	print(a)


rs = lambda : input()
ri = lambda : int(input())
rm = lambda : map(int, input().split())
rai = lambda : [int(x) for x in input().split()]

def solve(n):
	return n

def main():
	t = ri()
	for _ in range(t):
		n = ri()
		print(solve(n))
main()


import sys
from sys import stdin, stdout
from math import ceil, floor, sqrt, log, log2, log10
from collections import Counter
int_max = float('inf')
int_min = -float('inf')
ANS = []
input = stdin.readline

def solve():
	pass
t = int(input())
for i in range(t):
	n = int(input())
	ANS.append(str(n))
print('\n'.join(ANS))


for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print(1)
	else:
		print(n)


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nlargest, nsmallest
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from fractions import Fraction
mod = pow(10, 9) + 7
mod2 = 998244353

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

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
for _ in range(int(data())):
	out(int(data()))


a = int(input())
d = []
for i in range(a):
	d.append(input())
for i in d:
	print(i)


t = int(input())
while t:
	t -= 1
	n = int(input())
	if n == 0:
		print(0)
	else:
		print(n)


t = int(input())
lim = 10000000
while t != 0:
	n = input()
	print(n)
	t -= 1


import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
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 [int(x) for x in sys.stdin.readline().split()]

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

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

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

def S():
	return input()

def main():
	n = I()
	ans = []
	for _ in range(n):
		ans.append(I())
	for x in ans:
		print(x)
main()


for u in range(int(input())):
	ka = int(input())
	print(ka)


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

def gift():
	for _ in range(t):
		n = int(input())
		yield n
t = int(input())
ans = gift()
print(*ans, sep='\n')


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')
from math import factorial
from collections import Counter, defaultdict
from heapq import heapify, heappop, heappush

def RL():
	return map(int, sys.stdin.readline().rstrip().split())

def N():
	return int(input())

def comb(n, m):
	return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0

def perm(n, m):
	return factorial(n) // factorial(n - m) if n >= m else 0

def mdis(x1, y1, x2, y2):
	return abs(x1 - x2) + abs(y1 - y2)
mod = 1000000007
INF = float('inf')

def main():
	for _ in range(N()):
		n = N()
		print(n)
main()


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


n = int(input())
for t in range(n):
	m = int(input())
	print(m)


import sys
input = sys.stdin.readline

def inp():
	return int(input())
t = inp()
for i in range(t):
	print(inp())


t = int(input())
b = []
for i in range(t):
	n = int(input())
	b.append(n)
for i in range(t):
	print(b[i])


t = int(input())
for qwre in range(t):
	n = int(input())
	print(n)


def getInts():
	return list(map(int, input().split()))
[T] = getInts()
for case in range(T):
	[n] = getInts()
	print(n)


import math
T = int(input())
for t in range(T):
	n = int(input())
	print(n)


import os
import sys
debug = True
if debug and os.path.exists('input.in'):
	input = open('input.in', 'r').readline
else:
	debug = False
	input = sys.stdin.readline

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

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

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

def invr():
	return map(int, input().split())
test_count = int(input())
for t in range(test_count):
	n = inp()
	print(n)


from math import factorial as fac
from collections import defaultdict
from copy import deepcopy
import sys, math
f = None
try:
	f = open('q1.input', 'r')
except IOError:
	f = sys.stdin

def print_iterable(A):
	print(' '.join(A))

def read_int():
	return int(f.readline())

def read_int_array():
	return [int(x) for x in f.readline().strip().split(' ')]

def rns():
	a = [x for x in f.readline().split(' ')]
	return (int(a[0]), a[1].strip())

def read_string():
	return list(f.readline().strip())
NUMBER = 10 ** 9 + 7

def factorial(n):
	M = NUMBER
	f = 1
	for i in range(1, n + 1):
		f = f * i % M
	return f

def mult(a, b):
	return a * b % NUMBER

def minus(a, b):
	return (a - b) % NUMBER

def plus(a, b):
	return (a + b) % NUMBER

def egcd(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		(g, y, x) = egcd(b % a, a)
		return (g, x - b // a * y, y)

def modinv(a):
	m = NUMBER
	(g, x, y) = egcd(a, m)
	if g != 1:
		raise Exception('modular inverse does not exist')
	else:
		return x % m

def is_perfect_square(num):
	for i in range(2, 20):
		for j in range(1, num + 1):
			if j ** i == num:
				return True
	return False

def get_sum_perfect(num):
	res = 0
	for i in range(1, num + 1):
		if num % i == 0:
			if is_perfect_square(i):
				res += i
	return res

def real_solution(n):
	res = 0
	for i in range(1, n + 1):
		res += get_sum_perfect(i)
	return res
default_progs = [modinv(4), modinv(4), modinv(4)]
from random import randint
DEBUG = False

def solution1(N):
	result = N % NUMBER
	klom = int(N ** (1 / 3)) + 2
	for num in range(2, klom):
		if num in s:
			continue
		x = num ** 2
		power = num ** 2
		for p in range(2, int(math.log(N, num)) + 2):
			result = plus(result, mult(N // power, power))
			power *= num
	for num in range(klom, 2 * (int(N ** (1 / 3)) + 2)):
		result = plus(result, N * N * N)
	return result % NUMBER

def solution(N):
	return N

def main():
	T = read_int()
	for i in range(T):
		N = read_int()
		print(solution(N))

def main1():
	T = read_int()
	for i in range(T):
		N = read_int()
		print(solution(N))
main()


tc = int(input())
for _ in range(tc):
	x = input()
	print(x)


t = int(input())
for y in range(t):
	n = int(input())
	print(n)


def solve():
	print(input())
T = int(input())
for t in range(T):
	solve()


(t, *x) = map(int, open(0))
print(*x, sep='\n')


t = int(input().strip())
for _ in range(t):
	print(input().strip())


import sys
n = int(sys.stdin.readline())
for _ in range(n):
	a = int(sys.stdin.readline())
	print(a)


import sys
from collections import defaultdict, deque
from math import sqrt

def input():
	return sys.stdin.readline()[:-1]

def solve():
	n = int(input())
	print(n)
t = int(input())
for _ in range(t):
	solve()


import sys
input = sys.stdin.readline
Q = int(input())
Query = [int(input()) for _ in range(Q)]
for N in Query:
	print(N)


import sys
l = sys.stdin.readlines()
t = int(l[0].replace('\n', ''))
i = 1
for i in range(1, t + 1):
	print(l[i].replace('\n', ''))


import bisect
import os
import io
from collections import Counter
from collections import defaultdict
import math
import random
import heapq as hq
from math import sqrt
import sys
from functools import reduce, cmp_to_key
from collections import deque
import threading
from itertools import combinations

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

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

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

def rinput():
	return map(int, tinput())

def rlinput():
	return list(rinput())

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


def sol():
	n = int(input())
	for tt in range(n):
		print(input())
sol()


t = int(input())
while t != 0:
	t -= 1
	ans = int(input())
	print(ans)


def main():
	t = int(input())
	while t:
		N = int(input())
		print(N)
		t -= 1
main()


import sys
import math
fileoperation = 0
if fileoperation:
	orig_stdout = sys.stdout
	orig_stdin = sys.stdin
	inputfile = open('W:/Competitive Programming/input.txt', 'r')
	outputfile = open('W:/Competitive Programming/output.txt', 'w')
	sys.stdin = inputfile
	sys.stdout = outputfile
mod = 1000000007

def nospace(l):
	ans = ''.join((str(i) for i in l))
	return ans
t = int(input())
for tt in range(t):
	n = int(input())
	print(n)
if fileoperation:
	sys.stdout = orig_stdout
	sys.stdin = orig_stdin
	inputfile.close()
	outputfile.close()


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

def read_ints():
	ints = [int(x) for x in input().split(' ')]
	return ints

def solve(n):
	pass
t = read_int()
for case in range(t):
	n = read_int()
	print(n)


t = int(input().strip())
for iter in range(t):
	n = int(input().strip())
	print(n)


t = int(input())
for _ in range(t):
	n = int(input())
	res = 2 * (n - 1)
	if n == 1:
		res = 1
	res = n
	print(res)


import sys

def process(n):
	if n == 1:
		return 1
	if n == 2:
		return 2
	else:
		return process(n - 1) + 1
input = sys.stdin.readline

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

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

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

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

def f(a, n):
	return True

def is_permutation(arr):
	for e in range(1, len(arr) + 1):
		if e not in arr:
			return False
	return True
t = inp()
for i in range(t):
	n = inp()
	print(n)


for tini in range(int(input())):
	x = int(input())
	print(x)


T = int(input())
while T:
	n = int(input())
	print(n)
	T -= 1


res = []
t = int(input())
for i in range(t):
	n = int(input())
	res.append(n)
for i in res:
	print(i)


t = int(input())
for i in range(t):
	n = int(input())
	nod = (4 * n - 2) // 2
	print(n)


t = int(input())
for h in range(t):
	n = int(input())
	print(n)


import sys

def main():
	q = []
	for line in sys.stdin.readlines():
		q.append(line.rstrip())
	for i in range(1, len(q)):
		print(q[i])
main()


import sys
import math
input = sys.stdin.readline

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

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

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

def invr():
	return map(int, input().split())
nt = inp()
mylist = []
for i in range(0, nt):
	mylist.append(inp())
retval = []
for x in mylist:
	print(x)


print(*[*open(0)][1:])


import sys

def read_line():
	return sys.stdin.readline()
n = int(read_line())
for i in range(n):
	print(int(read_line()))


import os
import sys
from io import BytesIO, IOBase

def iin():
	return int(input())

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

def main():
	T = iin()
	while T:
		T -= 1
		print(iin())
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

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


import sys

def fib(n):
	F = [[1, 1], [1, 0]]
	if n == 0:
		return 0
	power(F, n - 1)
	return F[0][0]

def multiply(F, M):
	x = F[0][0] * M[0][0] + F[0][1] * M[1][0]
	y = F[0][0] * M[0][1] + F[0][1] * M[1][1]
	z = F[1][0] * M[0][0] + F[1][1] * M[1][0]
	w = F[1][0] * M[0][1] + F[1][1] * M[1][1]
	F[0][0] = x
	F[0][1] = y
	F[1][0] = z
	F[1][1] = w

def power(F, n):
	if n == 0 or n == 1:
		return
	M = [[1, 1], [1, 0]]
	power(F, n // 2)
	multiply(F, F)
	if n % 2 != 0:
		multiply(F, M)
sys.setrecursionlimit(100000000)
t = int(input())
for _ in range(t):
	n = int(input())
	print(n)


t = int(input())
for i in range(0, t):
	n = int(input())
	x = 4 * n - 2
	print(n)


T = int(input())
while T > 0:
	N = int(input())
	print(N)
	T = T - 1


import sys
t = int(sys.stdin.readline().rstrip())

def main():
	for _ in range(t):
		n = int(sys.stdin.readline().rstrip())
		print(n)
main()


tt = int(input())
while tt:
	n = int(input())
	print(n)
	tt -= 1


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


def diamond():
	k = input()
	print(k)
s = int(input())
for i in range(s):
	diamond()


def sol():
	return int(input())
for _ in range(int(input())):
	print(sol())


from sys import stdin, stdout
input = stdin.readline
for __ in range(int(input())):
	n = int(input())
	if n == 1:
		print(1)
	elif n == 2:
		print(2)
	else:
		print(n)


import sys
for line in sys.stdin:
	n = int(line)
	break
i = 0
for line in sys.stdin:
	print(line[:-1])
	i += 1
	if i >= n:
		break


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


def solve(a):
	print(a)

def main():
	t = int(input())
	for _ in range(t):
		a = int(input())
		solve(a)
main()


for _ in range(int(input())):
	a = int(input()) * 4 - 2
	x = a // 4 + 1
	print(x)


import math, sys
from collections import Counter

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

def ls():
	return list(map(int, list(input())))

def la():
	return list(input())

def i():
	return int(input())
t = i()
for _ in range(t):
	n = i()
	print(n)


from sys import stdout, stdin
(_input, _print) = (stdin.buffer.readline, stdout.write)
(_range, _int) = (range, int)

def solution():
	for _ in _range(_int(_input())):
		n = _int(_input())
		print(n)
solution()


from collections import Counter
for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print(1)
	else:
		print(n)


for ii in range(int(input())):
	n = int(input())
	print(n)


from sys import *
input = stdin.readline
for _ in range(int(input())):
	n = int(input())
	if n == 1:
		stdout.write(str(1) + '\n')
	else:
		stdout.write(str(n) + '\n')


import math
import sys
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda : map(int, input().split())
alele = lambda : list(map(int, input().split()))

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]
INF = 10 ** 18
MOD = 10 ** 9 + 7
from collections import deque
for _ in range(int(input())):
	N = int(input())
	print(N)


t = int(input())
for case_num in range(t):
	n = int(input())
	print(n)


n = int(input())
for i in range(0, n):
	o = int(input())
	print(o)


n = int(input())
l1 = []
for i in range(n):
	l1.append(int(input()))
for i in l1:
	print(i)


import sys
for i in range(int(input())):
	n = int(sys.stdin.readline())
	print(n)


import math

def solve(n):
	return n
t = int(input())
while t:
	n = int(input())
	print(solve(n))
	t -= 1


import os, sys, bisect, copy
from collections import defaultdict, Counter, deque
from functools import lru_cache
if os.path.exists('in.txt'):
	sys.stdin = open('in.txt', 'r')
if os.path.exists('out.txt'):
	sys.stdout = open('out.txt', 'w')

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

def mapi(arg=0):
	return map(int if arg == 0 else str, input().split())
for _ in range(int(input())):
	n = int(input())
	print(n)


t = int(input())
b = [0] * t
for i in range(0, t):
	b[i] = int(input())
for i in range(0, t):
	print(b[i])


T = int(input())
for i in range(0, T):
	a = int(input())
	print(a)


n = int(input())
v = [0] * n
for j in range(n):
	v[j] = int(input())
for k in range(n):
	print(v[k])


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


for __ in range(int(input())):
	n = int(input())
	print(n)


d = int(input())
while d:
	print(input())
	d -= 1


cases = int(input())
x = []
for i in range(0, cases):
	x.append(int(input()))
for i in range(0, cases):
	print(x[i])


import math as mt
for _ in range(int(input())):
	n = int(input())
	print(n)


import sys
from functools import reduce
import math
from itertools import groupby

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

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

def solve(n):
	return n
t = int(input())
while t > 0:
	n = I()
	ans = solve(n)
	print(ans)
	t -= 1


import sys
i = 0
threshold = -1
answer = ''
for line in sys.stdin:
	if i == 0:
		threshold = int(line)
		i += 1
		continue
	elif i == threshold:
		answer += line
		break
	else:
		answer += line
		i += 1
print(answer)