Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.

A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number. [Image] 

Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.


-----Input-----

The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 10^6) — the valence numbers of the given atoms.


-----Output-----

If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).


-----Examples-----
Input
1 1 2

Output
0 1 1

Input
3 4 5

Output
1 3 2

Input
4 1 1

Output
Impossible



-----Note-----

The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.

The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.

The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.

The configuration in the fourth figure is impossible as each atom must have at least one atomic bond.

Difficulty: EASY

Solutions:
a = list(map(int, input().split()))
if sum(a) % 2 == 1 or max(a) > sum(a) - max(a):
	print('Impossible')
elif len(set(a)) == 1:
	print(a[0] // 2, a[0] // 2, a[0] // 2)
elif a.count(min(a)) == 2:
	pos = a.index(max(a))
	ans = [0] * 3
	ans[pos] = ans[pos - 1] = max(a) // 2
	ans[pos - 2] = (min(a) * 2 - max(a)) // 2
	print(' '.join((str(ans[i]) for i in range(3))))
elif min(a) == a[0]:
	print(a[1] - sum(a) // 2 + a[0], sum(a) // 2 - a[0], a[2] - sum(a) // 2 + a[0])
elif min(a) == a[1]:
	print(a[0] - sum(a) // 2 + a[1], a[2] - sum(a) // 2 + a[1], sum(a) // 2 - a[1])
elif min(a) == a[2]:
	print(sum(a) // 2 - a[2], a[1] - sum(a) // 2 + a[2], a[0] - sum(a) // 2 + a[2])


(a, b, c) = map(int, input().split())
(x, y, z) = (0, 0, 0)
s = a + b + c
if s % 2 == 0:
	x = (a + b - c) // 2
	y = (b + c - a) // 2
	z = (a + c - b) // 2
	if x >= 0 and y >= 0 and (z >= 0):
		print(x, y, z)
	else:
		print('Impossible')
else:
	print('Impossible')


3
import sys

def solve(a, b, c):
	(ix, iy, iz) = (3, 2, 1)
	if b < a:
		(a, b) = (b, a)
		(ix, iy) = (iy, ix)
	if c < a:
		(a, c) = (c, a)
		(iz, iy) = (iy, iz)
	if c < b:
		(b, c) = (c, b)
		(iz, ix) = (ix, iz)
	x2 = a + (c - b)
	if x2 % 2 != 0:
		print('Impossible')
		return
	x = x2 // 2
	z = a - x
	y = c - x
	s = list(sorted([x, y, z]))
	if not all([n >= 0 for n in s]):
		print('Impossible')
		return
	if s.count(0) > 1:
		print('Impossible')
		return
	sol = [(ix, x), (iy, y), (iz, z)]
	sol.sort()
	print(sol[0][1], sol[1][1], sol[2][1])
(a, b, c) = [int(x) for x in sys.stdin.readline().strip().split()]
solve(a, b, c)


(a, b, c) = map(int, input().split())
ab = (a + b - c) / 2
bc = (b + c - a) / 2
ca = (c + a - b) / 2
i = 0
if ab == 0:
	i += 1
if bc == 0:
	i += 1
if ca == 0:
	i += 1
if i >= 2:
	print('Impossible')
elif ab != int(ab) or bc != int(bc) or ca != int(ca):
	print('Impossible')
elif ab >= 0 and bc >= 0 and (ca >= 0):
	print(int(ab), int(bc), int(ca))
else:
	print('Impossible')


(a, b, c) = map(int, input().split())
total = a + b + c
t = total
total //= 2
x = y = z = 0
x = total - c
y = total - a
z = total - b
if x < 0 or y < 0 or z < 0 or (t % 2 == 1):
	print('Impossible')
else:
	print(x, y, z)


(a, b, c) = map(int, input().split())
if True:
	diff = abs(b - c)
	if diff > a:
		print('Impossible')
	else:
		a -= diff
		if a % 2 == 0 and a <= 2 * min(c, b):
			if max(c, b) == b:
				print(diff + a // 2, c - a // 2, a // 2)
			else:
				print(a // 2, b - a // 2, diff + a // 2)
		else:
			print('Impossible')


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

def main():
	if os.path.exists('input.txt'):
		input = open('input.txt', 'r')
	else:
		input = sys.stdin
	(a, b, c) = list(map(int, input.readline().split()))
	lis = sorted([a, b, c])
	sol = [0, 0, 0]
	imp = True
	if lis[0] >= lis[2] - lis[1]:
		sol[2] = lis[2] - lis[1]
		lis[0] -= lis[2] - lis[1]
		lis[2] -= lis[2] - lis[1]
		if lis[0] % 2 == 0 and lis[1] == lis[2]:
			imp = False
			sol[0] += int(lis[0] / 2)
			sol[2] += int(lis[0] / 2)
			sol[1] = lis[2] - int(lis[0] / 2)
	if imp:
		output = 'Impossible'
	else:
		lassol = [0, 0, 0]
		if a == sol[0] + sol[2] and b == sol[0] + sol[1] and (c == sol[1] + sol[2]):
			lassol = [sol[0], sol[1], sol[2]]
		elif a == sol[0] + sol[2] and c == sol[0] + sol[1] and (b == sol[1] + sol[2]):
			lassol = [sol[2], sol[1], sol[0]]
		elif c == sol[0] + sol[2] and b == sol[0] + sol[1] and (a == sol[1] + sol[2]):
			lassol = [sol[2], sol[1], sol[0]]
		elif c == sol[0] + sol[2] and a == sol[0] + sol[1] and (b == sol[1] + sol[2]):
			lassol = [sol[1], sol[2], sol[0]]
		elif b == sol[0] + sol[2] and a == sol[0] + sol[1] and (c == sol[1] + sol[2]):
			lassol = [sol[0], sol[2], sol[1]]
		elif b == sol[0] + sol[2] and c == sol[0] + sol[1] and (a == sol[1] + sol[2]):
			lassol = [sol[2], sol[0], sol[1]]
		output = ' '.join(map(str, lassol))
	if os.path.exists('output.txt'):
		open('output.txt', 'w').writelines(str(output))
	else:
		sys.stdout.write(str(output))
main()


(a, b, c) = map(int, input().split())
s = (a + b + c) // 2
if (a + b + c) % 2 or s - a < 0 or s - b < 0 or (s - c < 0):
	print('Impossible')
else:
	print(s - c, s - a, s - b)


def solve(a, b, c):
	for i in range(a + 1):
		if b >= i and c + i >= a and (b - i == c - a + i):
			print(i, b - i, a - i)
			return
	print('Impossible')
(a, b, c) = list(map(int, input().split(' ')))
solve(a, b, c)


def print_molecules(array):
	max_valence = max(*array)
	max_pos = array.index(max_valence)
	array.remove(max_valence)
	if array[0] + array[1] < max_valence:
		print('Impossible')
		return
	if (array[0] + array[1] - max_valence) % 2 == 1:
		print('Impossible')
		return
	common_bond = (array[0] + array[1] - max_valence) // 2
	if max_pos == 0:
		print(f'{array[0] - common_bond} {common_bond} {array[1] - common_bond}')
	elif max_pos == 1:
		print(f'{array[0] - common_bond} {array[1] - common_bond} {common_bond}')
	else:
		print(f'{common_bond} {array[1] - common_bond} {array[0] - common_bond}')
molecules = input().split(' ')
for i in range(len(molecules)):
	molecules[i] = int(molecules[i])
print_molecules(molecules[:])


def isValid(x):
	if x >= 0 and x.is_integer():
		return True

def main():
	(n1, n2, n3) = [int(x) for x in input().split()]
	a = 0.5 * (n3 - n2 + n1)
	b = n3 - a
	c = n1 - a
	if isValid(a) and isValid(b) and isValid(c):
		print(' '.join((str(int(x)) for x in [c, b, a])))
	else:
		print('Impossible')
main()


def main():
	(a, b, c) = map(int, input().split())
	(res, flag) = ([], a ^ b ^ c ^ 1)
	for _ in range(3):
		x = (a + b - c) // 2
		flag &= x >= 0
		res.append(x)
		(a, b, c) = (b, c, a)
	print(*(res if flag else ('Impossible',)))
main()


cores = [int(i) for i in input().split()]
(bonds, total_bonds, max_bonds) = ([0, 0, 0], sum(cores), max(cores))
if total_bonds % 2 == 1 or max_bonds > total_bonds - max_bonds:
	print('Impossible')
	quit()
diff = (total_bonds - 2 * max_bonds) // 2
if cores[0] == cores[1] == cores[2]:
	for i in range(3):
		bonds[i] = max_bonds // 2
else:
	for i in range(3):
		if cores[i] != max_bonds and cores[(i + 1) % 3] != max_bonds:
			bonds[i] = diff
		elif cores[(i + 1) % 3] == max_bonds:
			bonds[i] = cores[i] - diff
		else:
			bonds[i] = cores[(i + 1) % 3] - diff
print(' '.join((str(i) for i in bonds)))


(a, b, c) = map(int, input().split())
s = 0
ma = max(a, b, c)
mi = min(a, b, c)
me = a + b + c - ma - mi
for i in range(mi + 1):
	if mi + me - 2 * i == ma:
		s = 1
		break
if s == 0:
	print('Impossible')
else:
	mime = i
	mima = mi - mime
	mame = me - mime
	if a == mi and b == me:
		print(mime, mame, mima)
	elif a == mi and b == ma:
		print(mima, mame, mime)
	elif a == me and b == mi:
		print(mime, mima, mame)
	elif a == me and b == ma:
		print(mame, mima, mime)
	elif a == ma and b == mi:
		print(mima, mime, mame)
	else:
		print(mame, mime, mima)


(a, b, c) = map(int, input().split())
x = a
y = 0
done = False
while x >= 0:
	if b - y == c - x and c - x >= 0:
		print(y, b - y, x)
		done = True
		break
	x -= 1
	y += 1
if not done:
	print('Impossible')


from operator import itemgetter

class CodeforcesTask344BSolution:

	def __init__(self):
		self.result = ''
		self.a_b_c = []

	def read_input(self):
		self.a_b_c = [int(x) for x in input().split(' ')]

	def process_task(self):
		a = self.a_b_c[0]
		b = self.a_b_c[1]
		c = self.a_b_c[2]
		if a > b + c or b > a + c or c > a + b:
			self.result = 'Impossible'
		else:
			connections = [0, 0, 0]
			updating = [[0, a], [1, b], [2, c]]
			cannot = False
			while sum(connections) * 2 != sum(self.a_b_c) and (not cannot):
				updating.sort(key=itemgetter(1), reverse=True)
				update_rate = updating[1][1] - updating[2][1]
				if not update_rate:
					if updating[1][1]:
						update_rate = updating[1][1] // 4
						if not update_rate:
							update_rate = 1
					else:
						cannot = True
				updating[0][1] -= update_rate
				updating[1][1] -= update_rate
				if updating[0][0] > updating[1][0]:
					if updating[0][0] - updating[1][0] > 1:
						connections[2] += update_rate
					else:
						connections[updating[1][0]] += update_rate
				elif updating[1][0] - updating[0][0] > 1:
					connections[2] += update_rate
				else:
					connections[updating[0][0]] += update_rate
			if cannot:
				self.result = 'Impossible'
			else:
				self.result = ' '.join([str(x) for x in connections])

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


(a, b, c) = map(int, input().split())
if (a + b + c) % 2 == 0:
	x = (a + b - c) // 2
	z = (a - b + c) // 2
	y = (-a + b + c) // 2
	if all((i >= 0 for i in [x, y, z])):
		print(x, y, z)
	else:
		print('Impossible')
else:
	print('Impossible')


(a, b, c) = map(int, input().split())
for i in range(max([a, b, c])):
	ab = i
	bc = b - ab
	ca = c - bc
	if (bc > 0 or ca > 0) and (bc >= 0 and ca >= 0):
		if ab + ca == a:
			print(ab, bc, ca)
			exit()
print('Impossible')


n = 3
a = list(map(int, input().strip().split()))[:n]
sum = sum(a)
rest = sum - max(a)
if sum % 2 == 1 or max(a) > rest:
	print('Impossible')
elif a[0] > a[1] and a[0] > a[2] and (a[1] > a[2]):
	i_1 = 0
	i_2 = 1
	i_3 = 2
	print(a[i_2] - a[i_3] + (a[i_1] - a[i_2] + a[i_3]) // 2, a[i_3] - (a[i_1] - a[i_2] + a[i_3]) // 2, (a[i_1] - a[i_2] + a[i_3]) // 2)
elif a[0] > a[1] and a[0] > a[2]:
	i_1 = 0
	i_2 = 2
	i_3 = 1
	print((a[i_1] - a[i_2] + a[i_3]) // 2, a[i_3] - (a[i_1] - a[i_2] + a[i_3]) // 2, a[i_2] - a[i_3] + (a[i_1] - a[i_2] + a[i_3]) // 2)
elif a[1] > a[2] and a[2] > a[0]:
	i_1 = 1
	i_2 = 2
	i_3 = 0
	print((a[i_1] - a[i_2] + a[i_3]) // 2, a[i_2] - a[i_3] + (a[i_1] - a[i_2] + a[i_3]) // 2, a[i_3] - (a[i_1] - a[i_2] + a[i_3]) // 2)
elif a[1] > a[2]:
	i_1 = 1
	i_2 = 0
	i_3 = 2
	print(a[i_2] - a[i_3] + (a[i_1] - a[i_2] + a[i_3]) // 2, (a[i_1] - a[i_2] + a[i_3]) // 2, a[i_3] - (a[i_1] - a[i_2] + a[i_3]) // 2)
elif a[1] > a[0]:
	i_1 = 2
	i_2 = 1
	i_3 = 0
	print(a[i_3] - (a[i_1] - a[i_2] + a[i_3]) // 2, a[i_2] - a[i_3] + (a[i_1] - a[i_2] + a[i_3]) // 2, (a[i_1] - a[i_2] + a[i_3]) // 2)
else:
	i_1 = 2
	i_2 = 0
	i_3 = 1
	print(a[i_3] - (a[i_1] - a[i_2] + a[i_3]) // 2, (a[i_1] - a[i_2] + a[i_3]) // 2, a[i_2] - a[i_3] + (a[i_1] - a[i_2] + a[i_3]) // 2)


(a, b, c) = map(int, input().split())
x = a + b - c
y = b + c - a
z = c + a - b
if any((x & 1, y & 1, z & 1, x < 0, y < 0, z < 0)):
	print('Impossible')
else:
	print(x // 2, y // 2, z // 2)


while 1:
	try:
		a = [0, 0, 0]
		(a[0], a[1], a[2]) = list(map(int, input().split()))
		b = sorted(a)
		c = sum(b[:2])
		d = (c - b[2]) // 2
		if b[2] > c or (c - b[2]) % 2 != 0:
			print('Impossible')
		else:
			ind = a.index(b[2]) + 1
			if ind == 1:
				print(a[1] - d, d, b[2] - (a[1] - d))
			elif ind == 2:
				print(a[0] - d, b[2] - (a[0] - d), d)
			else:
				print(d, a[1] - d, b[2] - (a[1] - d))
	except EOFError:
		break


aa = input().split()
a = int(aa[0])
b = int(aa[1])
c = int(aa[2])
x = str(int((a - c + b) / 2))
y = str(int((b - a + c) / 2))
z = str(int((c - b + a) / 2))
if '-' in x or '-' in y or '-' in z:
	print('Impossible')
else:
	i = str(x) + ' ' + str(y) + ' ' + str(z)
	if (x == '0' and y == '0' or (x == '0' and z == '0') or (y == '0' and z == '0')) or (a + b + c) % 2 != 0:
		print('Impossible')
	else:
		print(i)


def solve(a, b, c):
	if (a + b + c) % 2 == 1:
		return 'Impossible'
	if a + b < c or b + c < a or c + a < b:
		return 'Impossible'
	y = (c - a + b) // 2
	x = (b - c + a) // 2
	z = (c + a - b) // 2
	return '{} {} {}'.format(x, y, z)
(a, b, c) = list(map(int, input().split()))
print(solve(a, b, c))


inp = input().split()
a = int(inp[0])
b = int(inp[1])
c = int(inp[2])
if (a + b + c) % 2 == 1:
	print('Impossible')
else:
	all = (a + b + c) // 2
	f = all - c
	s = all - a
	t = all - b
	if f >= 0 and s >= 0 and (t >= 0):
		print(f, s, t)
	else:
		print('Impossible')


(a, b, c) = [int(x) for x in input().split()]
x = (a + b - c) / 2
y = (b + c - a) / 2
z = (a - b + c) / 2
if x - int(x) != 0 or y - int(y) != 0 or z - int(z) != 0:
	print('Impossible')
	exit(0)
x = int(x)
y = int(y)
z = int(z)
if x < 0 or y < 0 or z < 0:
	print('Impossible')
elif x == 0 and y == 0:
	print('Impossible')
elif x == 0 and z == 0:
	print('Impossible')
elif z == 0 and y == 0:
	print('Impossible')
else:
	print(x, y, z, sep=' ')


arr = list(map(int, input().split(' ')))
flag = False
for i in range(arr[0] + 1):
	if arr[0] - i + arr[1] - i == arr[2] and arr[1] - i >= 0 and (arr[0] - i >= 0):
		print(*[i, arr[1] - i, arr[0] - i], sep=' ')
		break
else:
	print('Impossible')


(a, b, c) = [int(x) for x in input().split()]
for x in range(min(a + 1, b + 1)):
	if a - x <= c and c - a + x == b - x:
		print(x, b - x, a - x)
		return
print('Impossible')


(a, b, c) = map(int, input().split())
ans = [(a + b - c) // 2, (b + c - a) // 2, (c + a - b) // 2]
if (a + b + c) % 2 == 1 or any((x < 0 for x in ans)):
	print('Impossible')
else:
	print(*ans)


import sys
(a, b, c) = map(int, sys.stdin.readline().split())
x = a
y = 0
done = False
while x >= 0:
	if b - y == c - x and c - x >= 0:
		print(y, b - y, x)
		done = True
		break
	x -= 1
	y += 1
if not done:
	print('Impossible')


from functools import reduce
from sys import stdin
file = stdin

def read_line():
	return file.readline().strip()

def read_int():
	return int(read_line())

def string_list_to_int_list(x):
	return [int(e) for e in x]
[x, y, z] = [0, 0, 0]
[a, b, c] = string_list_to_int_list(read_line().split(' '))
total = sum([a, b, c])
if total % 2 != 0:
	print('Impossible')
else:
	y = total // 2 - a
	z = b - y
	x = c - y
	if len(list(filter(lambda alpha: alpha < 0, [x, y, z]))) > 0:
		print('Impossible')
	else:
		print('{0} {1} {2}'.format(z, y, x))


(a, b, c) = map(int, input().split())
if (a + b - c) * (a - b + c) * (-a + b + c) < 0 or (a + b + c - 1) % 2 == 0:
	print('Impossible')
	exit()
print('%d %d %d' % ((a + b - c) // 2, (b + c - a) // 2, (c + a - b) // 2))


a = list(map(int, input().split()))
maxi = a.index(max(a))
mini = a.index(min(a))
if mini == maxi:
	mini += 1
midi = 3 - maxi - mini
link = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
link[midi][maxi] = link[maxi][midi] = a[midi] - a[mini]
a[maxi] -= a[midi] - a[mini]
a[midi] = a[mini]
link[midi][maxi] = link[maxi][midi] = a[maxi] - a[mini] + link[maxi][midi]
link[mini][maxi] = link[maxi][mini] = a[maxi] - a[mini] + link[maxi][mini]
a[mini] -= a[maxi] - a[mini]
if a[mini] < 0 or a[mini] % 2 == 1:
	print('Impossible')
else:
	print(link[0][1] + a[mini] // 2, ' ', link[1][2] + a[mini] // 2, ' ', link[2][0] + a[mini] // 2, sep='')


(a, b, c) = map(int, input().split())
if a + b + c < 2 * max(a, b, c) or (a + b + c) % 2:
	print('Impossible')
else:
	print((a + b - c) // 2, (b + c - a) // 2, (a + c - b) // 2)


(a, b, c) = map(int, input().split())
x = a
y = b
z = c
g = 0
if a > b + c or b > a + c or c > a + b or ((a + b + c) % 2 != 0):
	print('Impossible')
	exit(0)
if a >= b and a >= c:
	while x != y + z:
		g += 1
		y -= 1
		z -= 1
	print(y, g, z)
	exit(0)
if b >= a and b >= c:
	while y != x + z:
		g += 1
		x -= 1
		z -= 1
	print(x, z, g)
	exit(0)
if c >= a and c >= b:
	while z != x + y:
		g += 1
		x -= 1
		y -= 1
	print(g, y, x)


input = [int(i) for i in input().split()]
sum = sum(input)
if sum % 2 != 0:
	print('Impossible')
else:
	sum //= 2
	a = sum - input[2]
	b = sum - input[0]
	c = sum - input[1]
	if a >= 0 and b >= 0 and (c >= 0):
		print(a, b, c)
	else:
		print('Impossible')


def main():
	(a, b, c) = list(map(int, input().split(' ')))
	s = a + b + c
	if s % 2 != 0:
		return 'Impossible'
	x = (a - c + b) // 2
	y = b - x
	z = c - y
	if x < 0 or y < 0 or z < 0:
		return 'Impossible'
	return '{} {} {}'.format(x, y, z)
print(main())


import math
from collections import Counter
import math
(a, b, c) = map(int, input().split())
if (a + b + c) % 2 != 0:
	print('Impossible')
else:
	x = (a + b - c) // 2
	y = b - x
	z = a - x
	if x >= 0 and y >= 0 and (z >= 0):
		print(x, y, z)
	else:
		print('Impossible')


(a, b, c) = map(int, input().split())
for ac in range(10 ** 6):
	bc = c - ac
	ab = a - ac
	if bc < 0 or ab < 0:
		continue
	if ab + bc == b:
		print(ab, bc, ac)
		exit()
print('Impossible')


(x, y, z) = map(int, input().split())
c = 0
while x + z != y:
	c += 1
	x -= 1
	z -= 1
	if x < 0 or z < 0:
		print('Impossible')
		exit()
print(x, z, c)


l = list(map(int, input().split()))
d1 = l[0]
d2 = l[1]
d3 = l[2]
s = sum(l)
if sum(l) % 2 != 0:
	print('Impossible')
	exit()
a = d1 + d2 - d3
b = d2 + d3 - d1
c = d1 + d3 - d2
if min(a, b, c) < 0:
	print('Impossible')
else:
	a = a // 2
	b = b // 2
	c = c // 2
	if min(a + b, b + c, c + a) < 1:
		print('Impossible')
	else:
		print(a, b, c)


number = [int(c) for c in input().split(' ')]
number_1 = number.copy()
number.sort()
number_2 = number.copy()
chisla = [0, 0, 0]
if number[0] != number[1] and number[1] != number[2]:
	index_1 = number_1.index(number[0])
	index_2 = number_1.index(number[1])
	index_3 = number_1.index(number[2])
if number[0] == number[1]:
	index_1 = number_1.index(number[0])
	index_2 = number_1.index(number[1], index_1 + 1)
	index_3 = number_1.index(number[2])
if number[0] == number[1] == number[2]:
	index_1 = number_1.index(number[0])
	index_2 = number_1.index(number[1], index_1 + 1)
	index_3 = number_1.index(number[2], index_2 + 1)

def func(index_1, index_2):
	global chisla
	if index_1 + index_2 == 1:
		chisla[0] += 1
	elif index_1 + index_2 == 3:
		chisla[1] += 1
	elif index_1 + index_2 == 2:
		chisla[2] += 1
trig = True
while True:
	while number[2] != 0:
		number[2] -= 1
		number[1] -= 1
		func(index_3, index_2)
		if number[2] != 0 and number[0] > 0:
			number[2] -= 1
			number[0] -= 1
			func(index_3, index_1)
		if number[2] == number[1] and number[0] > 1:
			a = number[0]
			if a % 2 == 0:
				a = int(a / 2)
			else:
				trig = False
				break
			while a != 0:
				number[2] -= 1
				number[1] -= 1
				func(index_1, index_2)
				func(index_3, index_1)
				a -= 1
			number[0] = 0
	if trig == False:
		print('Impossible')
		break
	if number[1] > 0 and number[0] > 0:
		while number[1] != 0:
			number[1] -= 1
			number[0] -= 1
			func(index_1, index_2)
	elif number[1] == number[0] == 0:
		for a in chisla:
			print(a, end=' ')
		break
	else:
		print('Impossible')
		break
	if number[0] == number[1] == number[2] == 0:
		for a in chisla:
			print(a, end=' ')
		break
	else:
		print('Impossible')
		break


(a, b, c) = map(int, input().split())
x = (a + b - c) // 2
y = (b + c - a) // 2
z = (a + c - b) // 2
if x + z == a and x + y == b and (y + z == c) and (x > -1) and (y > -1) and (z > -1):
	print(x, y, z, sep=' ')
else:
	print('Impossible')


(a, b, c) = [int(x) for x in input().split()]
for x in range(min(a + 1, b + 1)):
	if a - x <= c and c - a + x == b - x:
		print(x, b - x, a - x)
		exit(0)
print('Impossible')


(a, b, c) = map(int, input().split())
l = [a, b, c]
l1 = []
if sum(l) % 2 == 0:
	t = sum(l) // 2
	l1.append(t - c)
	l1.append(t - a)
	l1.append(t - b)
	for i in l1:
		if i < 0:
			print('Impossible')
			quit(0)
	print(*l1)
else:
	print('Impossible')


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:
		from math import ceil, floor
		(a, b, c) = invr()
		for x in range(a + b + c + 1):
			y = b - x
			z = a - x
			if y + z == c and y >= 0 and (z >= 0):
				print(x, y, z)
				break
		else:
			print('Impossible')
	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()


x = [int(q) for q in input().split()]
s = sum(x) // 2
if sum(x) % 2 != 0:
	print('Impossible')
elif (s - x[2] < 0 or s - x[0] < 0 or s - x[1] < 0) or (s - x[2] == 0 and s - x[0] == 0 and (s - x[1] == 0)):
	print('Impossible')
else:
	print(s - x[2], s - x[0], s - x[1])


(a, b, c) = map(int, input().split())
n = abs(a - b)
if c < n or a + b < c or (c - n) % 2 != 0:
	print('Impossible')
else:
	m = (c - n) // 2
	if a > b:
		print(b - m, m, c - m)
	else:
		print(a - m, c - m, m)


(a, b, c) = map(int, input().split())
for i in range(a + 1):
	x = b - i
	y = c - x
	if i + y == a and i + x == b and (x + y == c) and (i >= 0) and (x >= 0) and (y >= 0):
		print(i, x, y)
		exit(0)
print('Impossible')


(x, y, z) = map(int, input().split())
ab = max(0, (x + y - z) // 2)
bc = max(0, (y + z - x) // 2)
ac = max(0, (x + z - y) // 2)
if ab + ac != x or ab + bc != y or ac + bc != z:
	print('Impossible')
else:
	print(ab, bc, ac)


(a, b, c) = map(int, input().split(' '))
Max = max(a, b, c)
Sum = sum([a, b, c])
if Max <= Sum - Max and Sum % 2 == 0:
	res = [(a + b - c) // 2, (b + c - a) // 2, (c + a - b) // 2]
	print(*res)
else:
	print('Impossible')


from fractions import *
import sys

def check(a):
	if a % 2 != 0:
		return False
	if a < 0:
		return False
	return True
readln = lambda : map(int, input().split())
(a, b, c) = readln()
if not check(b + c - a) or not check(a + b - c) or (not check(a + c - b)):
	print('Impossible')
	exit()
s23 = (b + c - a) // 2
s12 = (a + b - c) // 2
s13 = (a + c - b) // 2
print(s12, s23, s13)


(a, b, c) = map(int, input().split())
if (a + b + c) % 2:
	print('Impossible')
	exit(0)
z = (a + b + c) // 2
if z >= max(a, b, c) and z > sorted([a, b, c])[1]:
	print(z - c, z - a, z - b)
else:
	print('Impossible')


(x, y, z) = map(int, input().split())
x1 = [1, x]
x2 = [2, y]
x3 = [3, z]
arr = [x1, x2, x3]
a = 0
b = 0
x = 0
c = 0
arr = sorted(arr, key=lambda x: x[1])
while 1:
	arr = sorted(arr, key=lambda x: x[1])
	if arr[2][1] < 2:
		break
	i = 0
	while 1:
		if 2 ** i > arr[0][1]:
			break
		i += 1
	i = i - 1
	if arr[0][1] > 0 and i > 0:
		arr[0][1] -= 2 ** (i - 1)
		arr[1][1] -= 2 ** (i - 1)
		arr[2][1] -= 2 ** i
		if arr[2][0] == 1:
			a += 2 ** (i - 1)
			c += 2 ** (i - 1)
		elif arr[2][0] == 2:
			a += 2 ** (i - 1)
			b += 2 ** (i - 1)
		elif arr[2][0] == 3:
			b += 2 ** (i - 1)
			c += 2 ** (i - 1)
	elif arr[0][1] > 0 and i == 0:
		arr[0][1] -= 1
		arr[1][1] -= 1
		arr[2][1] -= 2
		if arr[2][0] == 1:
			a += 1
			c += 1
		elif arr[2][0] == 2:
			a += 1
			b += 1
		elif arr[2][0] == 3:
			b += 1
			c += 1
	elif arr[1][1] == arr[2][1] and arr[0][1] <= 0:
		x = arr[1][1]
		arr[1][1] = 0
		arr[2][1] = 0
		if arr[2][0] == 1 and arr[1][0] == 2 or (arr[2][0] == 2 and arr[1][0] == 1):
			a += x
		elif arr[2][0] == 2 and arr[1][0] == 3 or (arr[2][0] == 3 and arr[1][0] == 2):
			b += x
		elif arr[2][0] == 3 and arr[1][0] == 1 or (arr[2][0] == 1 and arr[1][0] == 3):
			c += x
	else:
		print('Impossible')
		exit()
if arr[0][1] == 0 and arr[1][1] == 0 and (arr[2][1] == 0):
	print(a, b, c)
elif arr[0][1] == 0 and arr[1][1] == 0 and (arr[2][1] == 1):
	print('Impossible')
elif arr[0][1] == 0 and arr[1][1] == 1 and (arr[2][1] == 1):
	if arr[2][0] == 1 and arr[1][0] == 2 or (arr[2][0] == 2 and arr[1][0] == 1):
		a += 1
	elif arr[2][0] == 2 and arr[1][0] == 3 or (arr[2][0] == 3 and arr[1][0] == 2):
		b += 1
	elif arr[2][0] == 3 and arr[1][0] == 1 or (arr[2][0] == 1 and arr[1][0] == 3):
		c += 1
	print(a, b, c)
elif arr[0][1] == 1 and arr[1][1] == 1 and (arr[2][1] == 1):
	print('Impossible')


(x, y, z) = map(int, input().split())
if x + y < z or y + z < x or z + x < y:
	print('Impossible')
	exit()
if (x + y + z) % 2 == 1:
	print('Impossible')
	exit()
a = x + y - z
a = a // 2
b = y - a
c = z - b
print(a, b, c)


(a, b, c) = map(int, input().split())
possible = False
(_a, _b, _c) = (0, 0, 0)
for A in range(0, min(a, b) + 1):
	C = a - A
	B = b - A
	if A + C == a and A + B == b and (B + C == c):
		possible = True
		_a = A
		_b = B
		_c = C
if possible:
	print(_a, _b, _c)
else:
	print('Impossible')


(a, b, c) = map(int, input().split())
summ = (a + b + c) // 2
if a > b + c or b > a + c or c > a + b or (a + b + c) % 2:
	print('Impossible')
	exit(0)
print(summ - c, summ - a, summ - b)


(a, b, c) = [int(i) for i in input().split()]
if (a + b + c) % 2:
	print('Impossible')
else:
	(ab, bc, ca) = ((b + a - c) // 2, (b + c - a) // 2, (c + a - b) // 2)
	if ab < 0 or bc < 0 or ca < 0:
		print('Impossible')
	else:
		print(ab, bc, ca)


(a, b, c) = map(int, input().split())
if (a + b + c) % 2 != 0:
	print('Impossible')
else:
	l = min(a, b)
	m = (a + b - c) // 2
	if m < 0 or m > l:
		print('Impossible')
	else:
		print(m, b - m, a - m)


import math
import sys
from collections import defaultdict
from collections import Counter
from collections import deque
import bisect
sys.setrecursionlimit(1000000)
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda : map(int, input().split())
alele = lambda : list(map(int, input().split()))
(x, y, z) = ilele()
aa = x + y - z
if aa < 0 or aa % 2 != 0:
	print('Impossible')
else:
	a = aa // 2
	one = a
	two = z - x + a
	three = x - a
	if one < 0 or two < 0 or three < 0:
		print('Impossible')
	else:
		print(one, two, three)


(a, b, c) = map(int, input().split())
ab = (a + b - c) // 2
bc = b - ab
ca = c - bc
print(['Impossible', ' '.join([str(ab), str(bc), str(ca)])][ab + ca == a and ab + bc == b and (ca + bc == c) and (ab >= 0) and (bc >= 0) and (ca >= 0)])


(a, b, c) = map(int, input().split())
ab = (a - c + b) // 2
bc = b - ab
ac = c - bc
if ab + ac == a and ab + bc == b and (ac + bc == c) and (ab >= 0) and (bc >= 0) and (ac >= 0):
	print(ab, bc, ac)
else:
	print('Impossible')


from collections import defaultdict, deque, Counter, OrderedDict
from bisect import insort, bisect_right, bisect_left
import threading, sys

def main():
	(a, b, c) = map(int, input().split())
	_13 = (a + c - b) // 2
	_12 = (a - c + b) // 2
	_23 = (b - a + c) // 2
	if a == _13 + _12 and b == _12 + _23 and (c == _23 + _13) and (min(_13, _12, _23) >= 0):
		print(_12, _23, _13)
	else:
		print('Impossible')
thread = threading.Thread(target=main)
thread.start()


import sys
input = sys.stdin.readline
from math import log2, log, ceil

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

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

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

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

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

def 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):
	while x != link[x]:
		x = link[x]
	return x

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)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(1000000.0 + 5)

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

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

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

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
(x, y, z) = int_array()
a = (x + y - z) / 2
b = (y - x + z) / 2
c = (z - y + x) / 2
if a >= 0 and b >= 0 and (c >= 0) and (int(a) == a) and (int(b) == b) and (int(c) == c):
	print(*(int(a), int(b), int(c)))
else:
	print('Impossible')


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

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

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

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

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

def array():
	return [int(i) for i in input().split()]
(a, b, c) = value()
count = 0
while a + c != b:
	count += 1
	a -= 1
	c -= 1
	if a < 0 or c < 0:
		print('Impossible')
		exit()
print(a, c, count)


gi = lambda : list(map(int, input().split()))
l = gi()
l = [(l[k], k) for k in range(3)]
l.sort()
(a, b, c) = (l[0][0], l[1][0], l[2][0])
if a < c - b or a - (c - b) & 1:
	print('Impossible')
	exit()
temp = [(a - (c - b)) // 2, b - (a - (c - b)) // 2, c - b + (a - (c - b)) // 2]
ans = {str(l[0][1]) + str(l[1][1]): temp[0], str(l[1][1]) + str(l[2][1]): temp[1], str(l[0][1]) + str(l[2][1]): temp[2], str(l[1][1]) + str(l[0][1]): temp[0], str(l[2][1]) + str(l[1][1]): temp[1], str(l[2][1]) + str(l[0][1]): temp[2]}
print(ans['01'], ans['12'], ans['02'])


tab = list(map(int, input().split(' ')))
if (tab[0] + tab[1] + tab[2]) % 2 == 1 or tab[0] + tab[1] < tab[2] or tab[0] + tab[2] < tab[1] or (tab[2] + tab[1] < tab[0]):
	print('Impossible')
else:
	print((tab[0] + tab[1] - tab[2]) // 2, (tab[1] + tab[2] - tab[0]) // 2, (tab[2] + tab[0] - tab[1]) // 2)