You are given two integers $a$ and $b$. Print $a+b$.


-----Input-----

The first line contains an integer $t$ ($1 \le t \le 10^4$) — the number of test cases in the input. Then $t$ test cases follow.

Each test case is given as a line of two integers $a$ and $b$ ($-1000 \le a, b \le 1000$).


-----Output-----

Print $t$ integers — the required numbers $a+b$.


-----Example-----
Input
4
1 5
314 15
-99 99
123 987

Output
6
329
0
1110

Source: codeforces | Difficulty: EASY
Tags: Implementation


Solutions:
for _ in range(int(input())):
	(a, b) = [int(i) for i in input().split()]
	print(a + b)


l = []
t = int(input())
for i in range(0, t):
	(a, b) = map(int, input().split())
	c = a + b
	l.append(c)
for i in l:
	print(i)


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


a = input()
i = int(a)
n = 0
while n < i:
	b = input()
	c = b.split(' ')
	print(int(c[0]) + int(c[1]))
	n += 1


for i in range(int(input())):
	l = [int(i) for i in input().split()]
	print(l[0] + l[1])


R = lambda : int(input())
S = lambda : map(int, input().split())
for _ in range(R()):
	(a, b) = S()
	print(a + b)


t = int(input())
if t > 0 and t < 10001:
	for i in range(t):
		(a, b) = map(int, input().split())
		if (a >= -1000 and b >= -1000) and (a <= 1000 and b <= 1000):
			print(a + b)


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


import math
import operator

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

def nCr(n, r):
	return math.factorial(n) / (math.factorial(r) * math.factorial(n - r))

def isKthBitSet(n, k):
	if n & 1 << k - 1:
		return True
	else:
		return False

def maximalRectangle(matrix):
	if not matrix or not matrix[0]:
		return 0
	n = len(matrix[0])
	height = [0] * (n + 1)
	ans = 0
	for row in matrix:
		for i in range(n):
			height[i] = height[i] + 1 if row[i] == '0' else 0
		stack = [-1]
		for i in range(n + 1):
			while height[i] < height[stack[-1]]:
				h = height[stack.pop()]
				w = i - 1 - stack[-1]
				ans = max(ans, h * w)
			stack.append(i)
	return ans

def matched(str):
	count = 0
	for i in str:
		if i == '(':
			count += 1
		elif i == ')':
			count -= 1
		if count < 0:
			return False
	return count == 0

def isValid(h, m, nh, nm):
	l = [0, 1, 5, -1, -1, 2, -1, -1, 8, -1]
	if l[h // 10] == -1 or l[h % 10] == -1 or l[m // 10] == -1 or (l[m % 10] == -1):
		return False
	resh = l[m % 10] * 10 + l[m // 10]
	resm = l[h % 10] * 10 + l[h // 10]
	return resh < nh and resm < nm

def solve():
	(a, b) = map(int, input().split())
	print(a + b)
t = int(input())
while t > 0:
	t -= 1
	solve()


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


t = int(input())

def print_sum(a, b):
	x = a + b
	return x
for i in range(t):
	(a, b) = input().split()
	a = int(a)
	b = int(b)
	print(print_sum(a, b))


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


res_ls = []
no = int(input())

def list():
	(x, y) = input().split()
	s = int(x)
	r = int(y)
	res = s + r
	res_ls.append(res)
	x = 0
	y = 0
i = 0
while i < no:
	list()
	i = i + 1
for t in res_ls:
	print(int(t))


a = int(input())
if a >= 0 and a <= 10000:
	sum = []
	for i in range(a):
		(b, c) = map(int, input().split())
		if b >= -1000 and b <= 1000 and (c >= -1000) and (c <= 1000):
			s = b + c
			sum.append(s)
	for j in range(a):
		print(sum[j])


tst = int(input())
vals = []
for i in range(0, tst):
	arr = (a, b) = [int(x) for x in input().split()]
	vals.append(arr)
for lst in vals:
	sum = 0
	for i in lst:
		sum += i
	print(sum)


m = int(input())
for i in range(m):
	(x, y) = input().split()
	x = int(x)
	y = int(y)
	print(x + y)


t = int(input())
for i in range(t):
	(a, b) = map(int, input().split())
	sum = a + b
	print(sum)


n = int(input())
for i in range(n):
	s = str(input())
	ans = 0
	a = [int(x) for x in s.split()]
	for i in a:
		ans += i
	print(ans)


n = int(input())
for i in range(n):
	(a, b) = map(int, input().split())
	print(a + b)


t = int(input())
d = dict()
for i in range(t):
	(a, b) = input().split()
	c = int(int(a) + int(b))
	d[i] = c
for i in range(t):
	print(d[i])


test = int(input())
ls = []
for i in range(test):
	(a, b) = map(int, input().split())
	s = a + b
	ls.append(s)
print(*ls, sep='\n')


x = input()
x = int(x)
while x > 0:
	line = input()
	line = line.split()
	a = int(line[0])
	b = int(line[1])
	y = a + b
	print(y)
	x = x - 1


import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda : int(input())
li = lambda : list(map(int, input().split()))

def case():
	(a, b) = li()
	print(a + b)
for _ in range(int(input())):
	case()


t = int(input())
p = []
for i in range(t):
	n = list(map(int, input().split()))
	p.append(n)
for i in range(t):
	k = p[i][0] + p[i][1]
	print(k)


t = int(input())
for i in range(t):
	(a, b) = [int(x) for x in input().split()]
	print(a + b)


import os
import sys
from io import BytesIO, IOBase

def main():
	pass
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

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

def test():
	(a, b) = map(int, input().split())
	return a + b
t = int(input())
for _ in range(t):
	print(test())


n = int(input())
arr = []
for i in range(n):
	arr.append(list(map(int, input().rstrip().split()[:2])))
for i in arr:
	print(i[0] + i[1])


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


import re
testCaseNumber = int(input())
listOfInput = []
temp = ''
tempSum = 0
sum = []
for index in range(int(testCaseNumber)):
	temp = input()
	listOfInput.append(temp)
	res = listOfInput[index].split(' ')
	tempSum = int(res[0]) + int(res[1])
	sum.append(tempSum)
	tempSum = 0
for index in range(testCaseNumber):
	print(sum[index])


n = int(input(''))
a = []
for i in range(0, n):
	a.append(input(''))
for i in range(0, n):
	(s1, s2) = map(int, a[i].split())
	print(s1 + s2)


t = int(input())
c = []
for i in range(t):
	(a, b) = map(int, input().split())
	c.append(a + b)
for e in c:
	print(e)


t = int(input())
for i in range(t):
	(a, b) = map(int, input().split())
	if a >= -1000 and a <= 1000:
		if b >= -1000 and b <= 1000:
			s = a + b
			print(s)


t = int(input())
res = dict()
for i in range(t):
	(a, b) = input().split()
	a = int(a)
	b = int(b)
	solve = a + b
	res[i] = solve
for i in range(t):
	print(res[i])


import sys
count = int(input())
r = []
for line in sys.stdin:
	n = line.split()
	r.append(int(n[0]) + int(n[1]))
	count -= 1
	if count == 0:
		break
for result in r:
	print(result)


n = int(input())
while n > 0:
	(a, b) = map(int, input().split())
	sum = a + b
	print(sum)
	n = n - 1


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


import sys, re, math
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from heapq import heappush, heappop, heapify, nlargest, nsmallest

def STR():
	return list(input())

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

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

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

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

def sortListWithIndex(listOfTuples, idx):
	return sorted(listOfTuples, key=lambda x: x[idx])

def sortDictWithVal(passedDic):
	temp = sorted(list(passedDic.items()), key=lambda kv: (kv[1], kv[0]))
	toret = {}
	for tup in temp:
		toret[tup[0]] = tup[1]
	return toret

def sortDictWithKey(passedDic):
	return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
t = INT()
while t != 0:
	(n, m) = MAP()
	print(n + m)
	t -= 1


result = ''
for i in range(0, int(input())):
	num = input()
	a = int(num.split()[0])
	b = int(num.split()[1])
	result += str(a + b) + '\n'
print(result.rstrip('\n'))


s = int(input())
sum = 0
for i in range(1, s + 1):
	a = input()
	a = a.split()
	result = [int(item) for item in a]
	for x in result:
		sum += x
	print(sum)
	sum = 0


t = int(input())
dddddd = []
for _ in range(t):
	(a, b) = map(int, input().split())
	dddddd.append(a + b)
for __ in dddddd:
	print(__)


t = int(input())
while t:
	(a, b) = map(int, input().split())
	print(a + b)
	t = t - 1


t = int(input())
while t > 0:
	(l, r) = map(int, input().split())
	print(l + r)
	t -= 1


for T in range(int(input())):
	a = input().split()
	print(int(a[0]) + int(a[1]))


n = int(input())
for i in range(n):
	(a, b) = [int(x) for x in input().split()]
	s = a + b
	print(s)


from sys import stdin, exit
input = stdin.readline

def i():
	return input()

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

def iis():
	return list(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):
	(a, b) = iis()
	print(a + b)


testCaseNumber = int(input())
testCase = []
for i in range(testCaseNumber):
	(r, t) = map(int, input().strip().split())
	testCase.append(r + t)
for i in testCase:
	print(i)


t = int(input())
if 1 <= t <= 100000:
	for i in range(t):
		(a, b) = map(int, input().split())
		if -1000 <= a and b <= 1000:
			print(a + b)


cases = int(input())
result = dict()
for i in range(cases):
	(a, b) = input().split()
	a = int(a)
	b = int(b)
	solve = a + b
	result[i] = solve
for i in range(cases):
	print(result[i])


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


a = int(input())
for i in range(a):
	(b, c) = map(int, input().split())
	print(b + c)


t = int(input())
for i in range(t):
	(s1, s2) = map(int, input().split())
	print(f'{s1 + s2}')


T = int(input())
for t in range(T):
	(a, b) = list(map(int, input().split()))
	print(a + b)


def main():

	def mostrar(L):
		for valor in L:
			print(valor)
	n = int(input())
	L = []
	while n > 0:
		ingreso = str(input())
		(a, b) = ingreso.split(' ')
		L.append(int(a) + int(b))
		n -= 1
	mostrar(L)
main()


for _ in range(int(input())):
	l = list(input().split(' '))
	print(int(l[0]) + int(l[1]))


n = int(input())
for x in range(n):
	(m, o) = map(int, input().split())
	print(m + o)


t = int(input())
l = []
for x in range(t):
	k = [int(_) for _ in input().split(' ')]
	l.append(k)
for x in l:
	print(sum(x))


t = int(input())
sum_list = []
for x in range(t):
	(a, b) = map(int, input().split())
	sum_list.append(a + b)
for sum in sum_list:
	print(sum)


def A_B(a, b):
	return a + b
Lista = []
total = int(input())
for i in range(total):
	All = [int(i) for i in input().split()]
	Lista.append(All)
for j in Lista:
	print(A_B(j[0], j[1]))


n = int(input())
for i in range(n):
	(p, q) = list(map(int, input().split()))
	print(p + q)


def solve(n, k):
	return n + k
t = int(input())
for i in range(t):
	(n, k) = tuple(map(int, input().split()))
	print(solve(n, k))


t = int(input())
for i in range(t):
	(a, b) = input().split(' ')
	a = int(a)
	b = int(b)
	s = a + b
	print(s)


t = int(input())
while t:
	t -= 1
	l = list(map(int, input().split()))
	print(l[0] + l[1])


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)
for _ in range(ii()):
	print(sum(mi()))


def main():
	test_cases = int(input())
	for _ in range(test_cases):
		(a, b) = [int(num) for num in input().split()]
		print(a + b)
main()


a = int(input())
for i in range(a):
	(n, m) = list(map(int, input().split()))
	print(n + m)


for x in range(int(input())):
	(a, b) = sorted(list(map(int, input().split())))
	c = a + b
	print(c)


n = int(input())
for i in range(n):
	(x, y) = map(int, input().split())
	print(x + y)


test = int(input())
for i in range(test):
	nums = str(input())
	nums = nums.split()
	print(int(nums[0]) + int(nums[1]))


n = int(input())
for item in range(n):
	k = list(map(int, input().split()))
	print(sum(k))


m = int(input())
l = []
for _ in range(m):
	(a, b) = map(int, input().split())
	l.append(a + b)
for i in l:
	print(i)


for i in range(int(input())):
	print(sum(map(int, input().split())))


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


def solve():
	(n1, k1) = map(int, input().split())
	return n1 + k1
tests = int(input())
while tests:
	tests -= 1
	print(solve())


from collections import deque
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from itertools import permutations
from datetime import datetime
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())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def solve():
	for _ in range(ii()):
		(a, b) = mi()
		print(a + b)

def __starting_point():
	solve()
__starting_point()


for ii in range(int(input())):
	(a, b) = list(map(int, input().split()))
	print(a + b)


t = int(input())
for i in range(t):
	(x, y) = input().split()
	x = int(x)
	y = int(y)
	print(x + y)


n = int(input())
while n:
	(a, b) = map(int, input().split())
	print(a + b)
	n -= 1


for _ in [*open(0)][1:]:
	(x, y) = map(int, _.split())
	print(x + y)


T = int(input())
for t_itr in range(T):
	(N, K) = list(map(int, input().rstrip().split()))
	print(N + K)


t = int(input())
for i in range(t):
	print(sum(list(map(int, input().split()))))


TN = int(input())
L = []
for i in range(TN):
	(a, b) = map(int, input().split())
	L.append(a + b)
for j in L:
	print(j)


noOfTestCases = int(input())
for i in range(noOfTestCases):
	(a, b) = input().split()
	a = int(a)
	b = int(b)
	print(a + b)


for i in range(int(input())):
	(n, m) = map(int, input().split())
	print(n + m)


no = []
length = int(input())
i = 1
while i <= length:
	num = input()
	no.append(num)
	i += 1
i = 1
while i <= length:
	numbers = no[0]
	add = numbers.split(' ')
	a = int(add[0])
	b = int(add[1])
	t = a + b
	print(t)
	no.remove(numbers)
	i += 1


n = int(input())
for i in range(n):
	num = input().split()
	print(int(num[0]) + int(num[1]))


t = int(input())
for i in range(t):
	l = [int(k) for k in input().split()]
	print(l[0] + l[1])


t = int(input())
L = []
while t:
	(a, b) = input().split()
	x = int(a)
	y = int(b)
	s = x + y
	L.append(s)
	t = t - 1
for i in L:
	print(i)


def fsm(a, b):
	print(a + b)
	return
t = int(input())
for i in range(t):
	T = input()
	l = list(map(int, T.split(' ')))
	fsm(l[0], l[1])


from collections import Counter
import math
nrew = int(input())
for wew in range(nrew):
	n = list(map(int, input().split(' ')))
	print(n[0] + n[1])


for s in [*open(0)][1:]:
	print(sum(map(int, s.split())))


t = int(input())
for i in range(t):
	a_b = input()
	result = a_b.split()
	result = [int(i) for i in result]
	print(sum(result))


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	print(n + k)


n = int(input())
i = 0
s = []
while i != n:
	s.append(list(map(int, input().split())))
	i += 1
for i in range(len(s)):
	print(sum(s[i]))


t = int(input())
i = 0
while i < t:
	i += 1
	(a, b) = list(map(int, input().split(' ')))
	print(a + b)


from sys import stdin
input = stdin.readline
t = int(input())
for _ in range(t):
	(a, b) = [int(x) for x in input().split()]
	print(a + b)


t = int(input())
ans = list()
for i in range(0, t):
	(a, b) = [int(a) for a in input().split()]
	ans = ans + [a + b]
for i in ans:
	print(i)


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


import sys

def main(_):
	num_inputs = int(sys.stdin.readline())
	for _ in range(num_inputs):
		test_str = sys.stdin.readline()
		(x_str, y_str) = test_str.split(' ')
		x = int(x_str)
		y = int(y_str)
		print(x + y)
main(sys.argv[1:])


t = int(input())
for it in range(t):
	(a, b) = [int(x) for x in input().split()]
	print(a + b)


t = int(input())
for _ in range(t):
	(a, b) = map(int, input().split())
	ans = 0
	for i in range(abs(a)):
		ans += abs(a) // a
	for i in range(abs(b)):
		ans += abs(b) // b
	print(ans)


t = int(input())
ri = lambda : map(int, input().split(' '))
for _ in range(t):
	(x, y) = ri()
	print(x + y)


t = int(input())
for i in range(t):
	b = list(map(int, input().split()))
	print(b[0] + b[1])


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

def read_int():
	return int(buff_readline())

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

def read_float():
	return float(buff_readline())

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

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

def read_str_n():
	return readline().strip().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

@mt
def slv(A, B):
	return A + B

def main():
	T = read_int()
	for _ in range(T):
		(A, B) = read_int_n()
		print(slv(A, B))
main()


import sys
import bisect
import heapq
from math import *
from collections import Counter as counter
from itertools import combinations as comb
from itertools import permutations as permutate
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
mod = pow(10, 9) + 7

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

def out(var):
	sys.stdout.write(str(var))

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

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def graph(vertex):
	return [[] for i in range(0, vertex + 1)]

def zerolist(n):
	return [0] * n

def nextline():
	out('\n')

def testcase(t):
	for p in range(t):
		solve()

def printlist(a):
	for p in range(0, len(a)):
		out(str(a[p]) + ' ')

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

def x(i):
	return i * (i + 1) + i * (i - 1) / 2

def solve():
	(a, b) = sep()
	print(a + b)
testcase(int(inp()))


a = int(input())
s = []
for i in range(1, a + 1):
	s.append(sum(map(int, input().split())))
for j in s:
	print(j)


for _ in range(int(input())):
	print(sum(list(map(int, input().split()))))


t = int(input())
if not (t <= 1 and t >= 10 ** 4):
	snum = []
	for i in range(t):
		snum.append(input())
	for i in snum:
		(a, b) = map(int, i.split())
		print(a + b)


for _ in range(int(input())):
	ar = list(map(int, input().split()))
	print(ar[0] + ar[1])


T = int(input())
for t in range(T):
	tmp = input().split()
	(a, b) = (int(tmp[0]), int(tmp[1]))
	print(a + b)


for i in range(int(input())):
	print(sum([int(x) for x in input().split(' ')]))


t = int(input())
l2 = []
if t >= 1 and t <= 10001:
	for i in range(t):
		l = input().split()
		a = int(l[0])
		b = int(l[1])
		x = int(a + b)
		l2.insert(i, x)
	for j in range(t):
		print(l2[j])


for _ in range(int(input())):
	(x, y) = map(int, input().split())
	print(x + y)


t = int(input())
count = 0
while count < t:
	count += 1
	l = list(map(int, input().split(' ')))
	print(sum(l))


testcases = input()
answers = list()
for case in range(int(testcases)):
	numbers = input()
	try:
		(a, b) = numbers.split()
		answers.append(int(a) + int(b))
	except ValueError as e:
		pass
for answer in answers:
	print(answer)


t = int(input())
if t <= 10000 and t >= 1:
	x = []
	for i in range(t):
		(a, b) = map(int, input().split())
		c = a + b
		x.append(c)
	for j in x:
		print(j)


t = int(input())
z = []
a = []
for i in range(t):
	a = input().split(' ')
	z.append(int(a[0]) + int(a[1]))
for i in range(t):
	print(z[i])


T = int(input())
for i in range(T):
	(a, b) = map(int, input().split())
	print(a + b)


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


def solve():
	nbCase = int(input())
	for i in range(nbCase):
		line = input()
		inputs = list(map(int, line.split()))
		res = inputs[0] + inputs[1]
		print(res)
solve()


test_cases = int(input())
for i in range(test_cases):
	(a, b) = map(int, input().split(' '))
	print(a + b)


testcase = int(input())
for i in range(testcase):
	list1 = list(map(int, input().split()))
	sum1 = sum(list1)
	print(sum1)


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


count = int(input())
for i in range(1, count + 1):
	(n1, n2) = map(int, input().split())
	print(n1 + n2)


n = int(input())
output = []
for i in range(n):
	A = input()
	(a, b) = A.split()
	output.append(int(a) + int(b))
for i in range(n):
	print(output[i])


k = int(input())
result = []
for i in range(0, k):
	(a, b) = input().split()
	c = int(a) + int(b)
	result.append(c)
for i in result:
	print(i)


for i in range(int(input())):
	(a, b) = list(map(int, input().split()))
	print(a + b)


ipnl = lambda n: [int(input()) for _ in range(n)]
inp = lambda : int(input())
ip = lambda : [int(w) for w in input().split()]
mp = lambda : map(int, input().split())
for _ in range(int(input())):
	(a, b) = mp()
	print(a + b)


t = int(input())
if 1 <= t <= 10000:
	list1 = list()
	for n in range(t):
		ch = input()
		(x, y) = ch.split()
		(a, b) = (int(x), int(y))
		if -1000 <= a <= 1000 and -1000 <= b <= 1000:
			list1.append(a + b)
	for i in list1:
		print(i)


t = int(input())
for _ in range(t):
	s = ''
	s = input()
	a = s.split(' ')
	print(int(a[0]) + int(a[1]))


n = int(input())
for i in range(n):
	print(sum(list(map(lambda x: int(x), input().split(' ')))))


t = int(input())
for i in range(t):
	s = input()
	s = s.split()
	print(int(s[0]) + int(s[1]))


t = int(input())
s = []
for _ in range(0, t):
	(a, b) = input().split()
	s.append(int(a) + int(b))
print(*s, sep='\n')


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


t = int(input())
sum = []
for i in range(t):
	(val1, val2) = map(int, input().split())
	sum.append(val1 + val2)
print(*sum, sep='\n')


for T in range(int(input())):
	x = input().split()
	print(int(x[0]) + int(x[1]))


t = int(input())
for i in range(t):
	(a, b) = input().split()
	if -1001 < int(a) < 1001 and -1001 < int(b) < 1001:
		s = int(a) + int(b)
		print(s)


t = int(input())
for i in range(t):
	ch = input()
	l = [int(j) for j in ch.split()]
	print(l[0] + l[1])


iSayisi = int(input())
islemler = []
for n in range(iSayisi):
	islemler.append(input())
for n in islemler:
	a = int(n.split()[0])
	b = int(n.split()[1])
	print(a + b)


import sys
import math
az = int(input())
while az != 0:
	az -= 1
	b = input().split()
	a = int(b[0])
	c = int(b[1])
	print(a + c)


casos = int(input())
k = 0
arr = []
while casos > k:
	k = k + 1
	(a, b) = [int(x) for x in input().split(' ')]
	res = a + b
	arr.append(res)
for k in arr:
	print(k)


def rec(n, z, l, x, y):
	if n > z:
		return l
	elif n == z:
		l.append(n)
		return l
	else:
		if n not in l:
			l.append(n)
		rec(n * x, z, l, x, y)
		rec(n * y, z, l, x, y)

def gcd(x, y):
	if x < y:
		(x, y) = (y, x)
	if y == 0:
		return x
	return gcd(y, x % y)

def lcm(x, y):
	if x < y:
		(x, y) = (y, x)
	gcd_ = gcd(x, y)
	return x * y // gcd_

def main_func():
	output_list = []
	t = int(input())
	for i in range(t):
		(x, y) = [int(i) for i in input().split(' ')]
		output_list.append(str(x + y))
	return '\n'.join(output_list)
print(main_func())