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: interview

Starter code:

Solutions:
import sys

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

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")
    return
s23 = (b+c-a)//2
s12 = (a+b-c)//2
s13 = (a+c-b) //2
print(s12,s23,s13)

3

import sys

def solve(a, b, c):
    ix, iy, iz = 3, 2, 1
    # sort
    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
    # solve
    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)


#Simple Molecules

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


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

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
                

                
            


a,b,c=list(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")


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:
##        m = min(L)//2
##        for i in (0,1,2):
##            ans[i]+=m
##            L[i]-=m*2
####        print(ans)
        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())
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")


def solve(a,b,c):
    #min of all 3
    # find all combinations
    #check equality
    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)


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)
    


a,b,c = list(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')


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

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())
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')
    return 
if a >= b and a >= c:
    while x != y + z:
        g += 1
        y -= 1
        z -= 1
    print(y, g, z)
    return
if b >= a and b >= c:
    while y != x + z:
        g += 1
        x -= 1
        z -= 1
    print(x, z, g)
    return
if c >= a and c >= b:
    while z != x + y:
        g += 1
        x -= 1
        y -= 1
    print(g, y, x) 

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


done=False
        
a,b,c=list(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())

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)

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

def main(nums):
	t = nums[0]
	for i in range(0, t+1): #between 1->2
		q = nums[1] #must be at 2
		w = q-i #between 2->3
		e = t-i #between 1->3
		r = nums[2] #must be at 3
		f = w+e #for real at 3

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

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