Takahashi has two integers X and Y.
He computed X + Y and X - Y, and the results were A and B, respectively.
Now he cannot remember what X and Y were. Find X and Y for him.

-----Constraints-----
 - -100 \leq A, B \leq 100
 - For the given integers A and B, there uniquely exist integers X and Y such that X + Y = A and X - Y = B.
 - All values in input are integers.

-----Input-----
Input is given from Standard Input in the following format:
A B

-----Output-----
Print X and Y.

-----Sample Input-----
2 -2

-----Sample Output-----
0 2

If X = 0 and Y = 2, they match the situation: 0 + 2 = 2 and 0 - 2 = -2.

Difficulty: MEDIUM_HARD

Solutions:
(a, b) = map(int, input().split())
print((a + b) // 2, (a - b) // 2)


(A, B) = map(int, input().split())
print(int((A + B) / 2), int((A - B) / 2))


(a, b) = map(int, input().split())
for x in range(-100, 101):
	for y in range(-100, 101):
		if x + y == a and x - y == b:
			print(x, y)
			break


(a, b) = map(int, input().split())
x = int((a + b) / 2)
y = a - x
print(x, y)


(a, b) = [int(i) for i in input().split()]
print((a + b) // 2, (a - b) // 2)


(A, B) = map(int, input().split())
X = (A + B) // 2
Y = (A - B) // 2
print(X, Y)


(x, y) = list(map(int, input().split()))
print((x + y) // 2, (x - y) // 2)


def resolve():
	(a, b) = map(int, input().split())
	print((a + b) // 2, (a - b) // 2)
resolve()


(X, Y) = map(int, input().split())
print((X + Y) // 2, (X - Y) // 2)


(A, B) = list(map(int, input().split()))
print('{} {}'.format((A + B) // 2, (A - B) // 2))


(a, b) = map(int, input().split())
for i in range(-1000, 1001):
	for j in range(-1000, 1001):
		if i + j == a and i - j == b:
			print(i, j)
			return


(A, B) = list(map(int, input().split()))
print(str(int((A + B) / 2)) + ' ' + str(int((A - B) / 2)))


import sys
from math import gcd, factorial, ceil, floor, sqrt
from bisect import bisect_left, bisect_right
from copy import deepcopy
from heapq import heapify, heappop, heappush
from itertools import permutations, combinations, product, accumulate
from collections import defaultdict, deque, Counter
from functools import lru_cache
sys.setrecursionlimit(10 ** 8)
ii = lambda : int(input())
mi = lambda : map(int, input().split())
li = lambda : list(map(int, input().split()))
(a, b) = mi()
print((a + b) // 2, (a - b) // 2)


def arc104_a():
	(a, b) = (int(x) for x in input().split())
	x = (a + b) // 2
	y = (a - b) // 2
	print(f'{x} {y}')
arc104_a()


(a, b) = input().split()
a1 = int(a)
b1 = int(b)
import math
x = math.floor((a1 + b1) / 2)
y = a1 - x
print(str(x) + ' ' + str(y))


(a, b) = list(map(int, input().split()))
x = (a + b) // 2
y = a - x
print(f'{x} {y}')


import sys
zz = 1
sys.setrecursionlimit(10 ** 5)
if zz:
	input = sys.stdin.readline
else:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('all.txt', 'w')
di = [[-1, 0], [1, 0], [0, 1], [0, -1]]

def fori(n):
	return [fi() for i in range(n)]

def inc(d, c, x=1):
	d[c] = d[c] + x if c in d else x

def ii():
	return input().rstrip()

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

def fli():
	return [float(x) for x in input().split()]

def comp(a, b):
	if a > b:
		return 2
	return 2 if a == b else 0

def gi():
	return [xx for xx in input().split()]

def gtc(tc, ans):
	print('Case #' + str(tc) + ':', ans)

def cil(n, m):
	return n // m + int(n % m > 0)

def fi():
	return int(input())

def pro(a):
	return reduce(lambda a, b: a * b, a)

def swap(a, i, j):
	(a[i], a[j]) = (a[j], a[i])

def si():
	return list(input().rstrip())

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

def gh():
	sys.stdout.flush()

def isvalid(i, j, n, m):
	return 0 <= i < n and 0 <= j < m

def bo(i):
	return ord(i) - ord('a')

def graph(n, m):
	for i in range(m):
		(x, y) = mi()
		a[x].append(y)
		a[y].append(x)
t = 1
uu = t
while t > 0:
	t -= 1
	(n, m) = mi()
	print((m + n) // 2, (n - m) // 2)


(a, b) = map(int, input().split())
for i in range(-100, 101):
	for j in range(-100, 101):
		if i + j == a and i - j == b:
			print(i, j)
			break


import sys

def S():
	return sys.stdin.readline().rstrip()

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

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

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

def LS():
	return list(sys.stdin.readline().rstrip().split())
(a, b) = MI()
print((a + b) // 2, (a - b) // 2)


(A, B) = map(int, input().split())
for X in range(-100, 101):
	for Y in range(-100, 101):
		if X + Y == A and X - Y == B:
			print(X, Y)


(A, B) = list(map(int, input().split()))
X = A / 2 + B / 2
Y = A / 2 - B / 2
print(str(int(X)) + ' ' + str(int(Y)))