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.

Source: codeforces | Difficulty: EASY
Tags: Graph algorithms

Mathematics

Complete search


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


t = input().split()
a = int(t[0])
b = int(t[1])
c = int(t[2])
d = a + b + c
x = 0
y = 0
z = 0
if a * b * c != 0 and d // 2 * 2 == d:
	x = int((a + b - c) / 2)
	y = int((b + c - a) / 2)
	z = int((c + a - b) / 2)
	if x >= 0 and y >= 0 and (z >= 0):
		print(x, y, z)
	else:
		print('Impossible')
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()


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


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


import sys
MOD = 1000000007

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

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

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

def print_array(a):
	print(' '.join(map(str, a)))

def main():
	(a, b, c) = get_ints()
	(x, y, z) = ((b + c - a) // 2, (a + c - b) // 2, (a + b - c) // 2)
	if x < 0 or y < 0 or z < 0 or ((a + b + c) % 2 == 1):
		print('Impossible')
	else:
		print(z, x, y)
main()


def __starting_point():
	inp = input()
	arr = inp.split(' ')
	L = [int(x) for x in arr]
	ans = [0, 0, 0]
	s = 0
	for l in L:
		s += l
	imp = False
	for l in L:
		if l > s / 2:
			imp = True
	if imp:
		print('Impossible')
	else:
		imp = False
		if L[0] == min(L):
			if L[1] > L[2]:
				bonds = L[1] - L[2]
				ans[0] += bonds
				L[0] -= bonds
				L[1] -= bonds
			else:
				bonds = L[2] - L[1]
				ans[2] += bonds
				L[0] -= bonds
				L[2] -= bonds
			if L[0] % 2 == 1:
				imp = True
			else:
				bonds = L[0] // 2
				ans[0] += bonds
				ans[2] += bonds
				ans[1] += (L[1] + L[2]) // 2 - bonds
		elif L[1] == min(L):
			if L[0] > L[2]:
				bonds = L[0] - L[2]
				ans[0] += bonds
				L[1] -= bonds
				L[0] -= bonds
			else:
				bonds = L[2] - L[0]
				ans[1] += bonds
				L[1] -= bonds
				L[2] -= bonds
			if L[1] % 2 == 1:
				imp = True
			else:
				bonds = L[1] // 2
				ans[0] += bonds
				ans[1] += bonds
				ans[2] += (L[0] + L[2]) // 2 - bonds
		else:
			if L[0] > L[1]:
				bonds = L[0] - L[1]
				ans[2] += bonds
				L[2] -= bonds
				L[0] -= bonds
			else:
				bonds = L[1] - L[0]
				ans[1] += bonds
				L[2] -= bonds
				L[1] -= bonds
			if L[2] % 2 == 1:
				imp = True
			else:
				bonds = L[2] // 2
				ans[2] += bonds
				ans[1] += bonds
				ans[0] += (L[0] + L[1]) // 2 - bonds
		for i in ans:
			if i < 0:
				imp = True
		if imp:
			print('Impossible')
		else:
			for i in range(3):
				print(ans[i], end=' ')
			print()
__starting_point()


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


numbers = input()
numbers = numbers.split()
if len(numbers) != 3:
	print('Impossible')
	exit()
a = int(numbers[0])
b = int(numbers[1])
c = int(numbers[2])
if (a + b + c) % 2 != 0:
	print('Impossible')
	exit()
x = (a + b - c) // 2
y = (b + c - a) // 2
z = (a + c - b) // 2
if x < 0 or y < 0 or z < 0 or (x == 0 and y == 0 and (z == 0)):
	print('Impossible')
	exit()
print(str(int(x)) + ' ' + str(int(y)) + ' ' + str(int(z)))


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


v = [[0] * 2 for i in range(3)]
for i in range(3):
	v[i][1] = i
(v[0][0], v[1][0], v[2][0]) = map(int, input().split())
ways = [[0] * 3 for i in range(3)]
v.sort(reverse=True)
cord = [0] * 3
for i in range(3):
	for j in range(3):
		if v[j][1] == i:
			cord[j] = i
check = False
for i in range(v[1][0], 0, -1):
	if v[0][0] - i + v[1][0] - i == v[2][0]:
		ways[cord[0]][cord[1]] = i
		ways[cord[1]][cord[2]] = v[1][0] - i
		ways[cord[2]][cord[0]] = v[0][0] - i
		ways[cord[1]][cord[0]] = i
		ways[cord[2]][cord[1]] = v[1][0] - i
		ways[cord[0]][cord[2]] = v[0][0] - i
		check = True
		break
if check:
	print(ways[0][1], ways[1][2], ways[2][0])
else:
	print('Impossible')


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


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


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


(a, b, c) = map(int, input().split())
if (a + b + c) % 2 == 1:
	print('Impossible')
	quit()
aTob = (a + b - c) // 2
bToc = (b + c - a) // 2
cToa = (c + a - b) // 2
if min(aTob, bToc, cToa) >= 0:
	print(aTob, bToc, cToa)
else:
	print('Impossible')


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


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


from math import ceil, floor
(a, b, c) = map(int, input().split())
bond = [a, b, c]
bond.sort()
ans = []
x = (a + b - c) / 2
if ceil(x) == floor(x) and x >= 0:
	x = int(x)
	y = b - x
	z = c - y
	ans.append(x)
	ans.append(y)
	ans.append(z)
	if y < 0 or z < 0:
		print('Impossible')
	else:
		print(*ans)
else:
	print('Impossible')


(a, b, c) = map(int, input().split())
m = max(a, b, c)
if (a + b + c) % 2 != 0:
	print('Impossible')
else:
	x = 0
	k = 1
	while x < m:
		if c == a - x + (b - x) and a - x >= 0 and (b - x >= 0):
			k = 0
			break
		x += 1
	if k != 1:
		print(x, b - x, a - x)
	else:
		print('Impossible')


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


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


def main(nums):
	t = nums[0]
	for i in range(0, t + 1):
		q = nums[1]
		w = q - i
		e = t - i
		r = nums[2]
		f = w + e
		if r != f or w < 0:
			continue
		else:
			return '{} {} {}'.format(i, w, e)
	return 'Impossible'

def init():
	nums = list(map(int, input().split()))
	print(main(nums))
init()


a = [*map(int, input().split())]
s = sum(a)
if s % 2 or any((s // 2 - j < 0 for j in a)):
	print('Impossible')
else:
	print(s // 2 - a[2], s // 2 - a[0], s // 2 - a[1])


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


(a, b, c) = map(int, input().split())
n23 = (b + c - a) / 2
n13 = c - n23
n12 = a - n13
if n23 < 0 or n13 < 0 or n12 < 0 or (n23 != int(n23)):
	print('Impossible')
	exit()
print(int(n12), int(n23), int(n13))


(a, b, c) = map(int, input().split())
l = [(a, 0), (b, 1), (c, 2)]
l.sort()
m = {}
((a, x), (b, y), (c, z)) = l
if a + b >= c and (a + b - c) % 2 == 0:
	tmp = m[x, y] = m[y, x] = (a + b - c) // 2
	m[x, z] = m[z, x] = a - tmp
	m[y, z] = m[z, y] = b - tmp
	print(m[0, 1], m[1, 2], m[0, 2])
else:
	print('Impossible')


import sys
import string
from collections import Counter, defaultdict
from math import fsum, sqrt, gcd, ceil, factorial
from operator import *
from itertools import accumulate
inf = float('inf')
flush = lambda : sys.stdout.flush
comb = lambda x, y: factorial(x) // factorial(y) // factorial(x - y)
ip = lambda : input()
ii = lambda : int(input())
r = lambda : map(int, input().split())
rr = lambda : list(r())
arr = rr()
s = sum(arr) // 2
if sum(arr) % 2 or any((i > s for i in arr)):
	print('Impossible')
else:
	print(s - arr[2], s - arr[0], s - arr[1])


def f(l):
	(a, b, c) = l
	if sum(l) % 2 > 0:
		return ['Impossible']
	ab = (a + b - c) // 2
	ac = (a + c - b) // 2
	bc = (b + c - a) // 2
	l = [ab, bc, ac]
	if sum([i == 0 for i in l]) > 1 or sum([i < 0 for i in l]) > 0:
		return ['Impossible']
	return l
l = list(map(int, input().split()))
print(*f(l))


(a, b, c) = [int(x) for x in input().split()]

def solve(a, b, c):
	for i in range(a + 1):
		l1 = i
		l2 = b - i
		l3 = a - i + l2
		if l3 == c and l3 >= 0 and (l2 >= 0) and (l2 != 0 or l3 != 0):
			print(l1, end=' ')
			print(l2, end=' ')
			print(a - i)
			return
	print('Impossible')
solve(a, b, c)


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


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


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


(A, B, C) = map(int, input().split())
x = y = (A - C + B) / 2
z = (C - A + B) / 2
if x % 1 != 0 or z % 1 != 0 or x < 0 or (z < 0) or (C - int(z) < 0):
	print('Impossible')
else:
	print(int(x), int(z), C - int(z))


a = input().split(' ')
first = int(a[0])
second = int(a[1])
third = int(a[2])
sum = first + second + third
if sum % 2 == 1:
	print('Impossible')
else:
	x = first
	y = second
	z = third
	if x - int(x) != 0 or y - int(y) != 0 or z - int(z) != 0:
		print('Impossible')
	else:
		x = int(sum / 2 - third)
		y = int(sum / 2 - first)
		z = int(sum / 2 - second)
		if x < 0 or y < 0 or z < 0 or (x == 0 and y == 0 and (z == 0)):
			print('Impossible')
		else:
			print(x, y, z)


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


inp = input().split(' ')
a = int(inp[0])
b = int(inp[1])
c = int(inp[2])
all_b = a + b + c
if all_b % 2 == 0:
	all_b = int(all_b / 2)
	x = all_b - c
	y = all_b - a
	z = all_b - b
	if x >= 0 and y >= 0 and (z >= 0):
		print(str(x) + ' ' + str(y) + ' ' + str(z))
	else:
		print('Impossible')
else:
	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')


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


(a, b, c) = map(int, input().split())
if a >= b and a >= c:
	if a > b + c:
		print('Impossible')
	elif a == b + c:
		print(b, 0, c)
	else:
		i = 2
		flag = 0
		while b + c - i >= a:
			if a == b + c - i:
				print(b - i // 2, i // 2, c - i // 2)
				flag = 1
				break
			i += 2
		if flag == 0:
			print('Impossible')
elif b >= a and b >= c:
	if b > a + c:
		print('Impossible')
	elif b == a + c:
		print(a, c, 0)
	else:
		i = 2
		flag = 0
		while a + c - i >= b:
			if b == a + c - i:
				print(a - i // 2, c - i // 2, i // 2)
				flag = 1
				break
			i += 2
		if flag == 0:
			print('Impossible')
elif c >= b and c >= a:
	if c > b + a:
		print('Impossible')
	elif c == b + a:
		print(0, b, a)
	else:
		i = 2
		flag = 0
		while b + a - i >= c:
			if c == b + a - i:
				print(i // 2, b - i // 2, a - i // 2)
				flag = 1
				break
			i += 2
		if flag == 0:
			print('Impossible')


v = list(map(int, input().split()))
found = False
for i in range(v[0] + 1):
	a = i
	b = v[0] - i
	if v[1] - a < 0 or v[2] - b < 0:
		continue
	if v[1] - a == v[2] - b:
		print(a, v[1] - a, b)
		found = True
		break
if not found:
	print('Impossible')


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


(n, m, k) = map(int, input().split())
mm = max(n, m, k)
ss = n + m + k - 2 * mm
if ss % 2 != 0 or ss < 0:
	print('Impossible')
else:
	a = ss // 2
	if n == mm:
		print(m - a, a, k - a)
	elif m == mm:
		print(n - a, k - a, a)
	else:
		print(a, m - a, n - a)


data = input().split(' ')
a = int(data[0])
b = int(data[1])
c = int(data[2])
x = 0
y = 0
z = 0
if (a - b + c) % 2 != 0:
	print('Impossible')
else:
	z = int((a - b + c) / 2)
	x = int(a - z)
	y = int(b - x)
	if x == y == 0 or x == z == 0 or z == y == 0:
		print('Impossible')
	elif min(x, y, z) >= 0:
		print('%s %s %s' % (x, y, z))
	else:
		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())
(s, m) = divmod(a + b + c, 2)
if m or s < a or s < b or (s < c):
	print('Impossible')
else:
	print(s - c, s - a, s - b)


def main():
	(a, b, c) = map(int, input().split())
	(res, flag) = ([], a + b + c & 1)
	for (x, y, z) in ((a, b, c), (b, c, a), (c, a, b)):
		xy = (x + y - z) // 2
		flag |= xy < 0
		res.append(xy)
	if flag:
		print('Impossible')
	else:
		print(*res)
main()


def checkValid(a, b, c):
	if a >= 0 and b >= 0 and (c >= 0) and a.is_integer() and b.is_integer() and c.is_integer():
		return True
	else:
		return False
(a, b, c) = [int(x) for x in input().split()]
x = (a + b - c) / 2
y = (c + b - a) / 2
z = (c - b + a) / 2
if checkValid(x, y, z):
	print(int(x), ' ', int(y), ' ', int(z))
else:
	print('Impossible')


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


(a, b, c) = map(int, input().split())
Sum = a + b + c
if Sum % 2 == 0:
	A = [[a, 1], [b, 2], [c, 3]]
	A.sort()
	if A[0][0] + A[1][0] >= A[2][0]:
		y = A[0][0] + A[1][0]
		p = y - A[2][0]
		Dict = {}
		Dict[''.join(list(map(str, sorted([A[0][1], A[1][1]]))))] = p // 2
		Dict[''.join(list(map(str, sorted([A[1][1], A[2][1]]))))] = A[1][0] - p // 2
		Dict[''.join(list(map(str, sorted([A[0][1], A[2][1]]))))] = A[0][0] - p // 2
		print(Dict['12'], Dict['23'], Dict['13'])
	else:
		print('Impossible')
else:
	print('Impossible')


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


def moleculas(a, b, c):
	if a == 0 or b == 0 or c == 0:
		return ['Impossible']
	if a + b - c < 0 or (a + b - c) % 2 == 1:
		return ['Impossible']
	d = (a + b - c) // 2
	(e, f) = (b - d, a - d)
	if d >= 0 and e >= 0 and (f >= 0):
		return (d, e, f)
	else:
		return ['Impossible']
(A, B, C) = [int(i) for i in input().split()]
print(*moleculas(A, B, C))


(a, b, c) = map(int, input().split())

def enough(t, v, v1):
	if t <= v + v1:
		return True
	else:
		return False
if enough(a, b, c) and enough(b, a, c) and enough(c, b, a) and ((a + b + c) % 2 == 0):
	x = round((a + b - c) / 2)
	y = round((c + b - a) / 2)
	z = round((a + c - b) / 2)
	print('{} {} {}'.format(x, y, z))
else:
	print('Impossible')


import sys
(a, b, c) = [int(x) for x in sys.stdin.readline().strip().split()]
sumd = a + b + c
if sumd % 2 == 0:
	sumd = sumd // 2
	x = sumd - c
	y = sumd - a
	z = sumd - b
	if x >= 0 and y >= 0 and (z >= 0):
		print(x, y, z)
	else:
		print('Impossible')
else:
	print('Impossible')


from sys import stdin
from sys import stdout

def readdata():
	global a, b, c
	(a, b, c) = [int(x) for x in stdin.readline().split()]

def solve():
	for x in range(a + 1):
		z = a - x
		y = b - x
		if y + z == c and y >= 0 and (z >= 0):
			print(x, y, z)
			return
	print('Impossible')
readdata()
solve()


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