Polycarp has guessed three positive integers $a$, $b$ and $c$. He keeps these numbers in secret, but he writes down four numbers on a board in arbitrary order — their pairwise sums (three numbers) and sum of all three numbers (one number). So, there are four numbers on a board in random order: $a+b$, $a+c$, $b+c$ and $a+b+c$.

You have to guess three numbers $a$, $b$ and $c$ using given numbers. Print three guessed integers in any order.

Pay attention that some given numbers $a$, $b$ and $c$ can be equal (it is also possible that $a=b=c$).


-----Input-----

The only line of the input contains four positive integers $x_1, x_2, x_3, x_4$ ($2 \le x_i \le 10^9$) — numbers written on a board in random order. It is guaranteed that the answer exists for the given number $x_1, x_2, x_3, x_4$.


-----Output-----

Print such positive integers $a$, $b$ and $c$ that four numbers written on a board are values $a+b$, $a+c$, $b+c$ and $a+b+c$ written in some order. Print $a$, $b$ and $c$ in any order. If there are several answers, you can print any. It is guaranteed that the answer exists.


-----Examples-----
Input
3 6 5 4

Output
2 1 3

Input
40 40 40 60

Output
20 20 20

Input
201 101 101 200

Output
1 100 100

Difficulty: introductory

Starter code:

Solutions:
A = list(map(int, input().split()))
A.sort()
print(A[3] - A[0], A[3] - A[2], A[3] - A[1])


def main():
    a, b, c, d = sorted(map(int, input().split()))
    print(d - a, d - b, d - c)
    return 0
main()

a, b, c, d = sorted(list(map(int, input().split())))
print(d - a, d - b, d - c)


arr=list(map(int,input().split()))
arr.sort()
ans=[]
for i in range(3):
	ans.append(arr[-1]-arr[i])
print(*ans)

a, b, c, d = sorted(map(int, input().split()))
print(d - a, d - b, d - c)


x1,x2,x3,x4 = map(int,input().split())

s1 = max(x1,x2,x3,x4)

for i in [x1,x2,x3,x4]:
	if i!=s1:
		print(s1-i,end=' ')

l = list(map(int,input().split()))
k = max(l)
for i in l:
	if i != k:
		print(k - i, end = " ")
		

A = sorted([int(a) for a in input().split()])
m = A[-1]
print(m-A[2], m-A[1], m-A[0])


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

a = list(mp())
a.sort(reverse = True)
print(a[0] - a[1], a[0] - a[2], a[0] - a[3])

#  =========     /\       /|    |====/|
#      |        /  \       |    |   / |
#      |       /____\      |    |  /  |
#      |      /      \     |    | /   |
#  ========= /        \  =====  |/====|  
#  code

from collections import Counter
def __starting_point():
    d = list(map(int,input().split()))
    d.sort()
    a = d[0]
    b = d[1]
    c = d[2]
    d = d[3]
    x = d - a
    y = d - b
    z = d - c

    print(x,y,z)
__starting_point()

a = list(map(int, input().split()))
a.sort()
for i in a[:-1]:
	print(a[-1]-i, end=" ")

x1, x2, x3, x4 = map(int, input().split())
s = [x1, x2, x3, x4]
s.sort()
for i in range(3):
    print(s[-1] - s[i], end=' ')

# -*- coding: utf-8 -*-

ab, ac, bc, abc = sorted(map(int, input().split()))
print(ab + ac - abc, ab + bc -abc, bc + ac - abc)


l=[int(i) for i in input().split()]
l.sort()
m=l[3]
print(m-l[0],m-l[1],m-l[2])

l = list(map(int,input().split()))
l.sort()

print(l[-1] - l[0] , l[-1]-l[1] , l[-1]-l[2])


a = [int(e) for e in input().split()]
a.sort()
A = a[-1] - a[0]
B = a[-1] - a[1]
C = a[-1] - a[2]
print(A, B, C)


a = list(map(int, input().split()))
a.sort()
print(a[3]-a[0], a[3]-a[1], a[3]-a[2])


arr = list(map(int , input().split()))
arr.sort()
print(arr[-1] - arr[0] ,arr[-1] -arr[1] , arr[-1]-arr[2] )


#	!/usr/bin/env python3
#	encoding: UTF-8
#	Modified: <16/Apr/2019 08:07:57 PM>


#	✪ H4WK3yE乡
#	Mohd. Farhan Tahir
#	Indian Institute Of Information Technology (IIIT),Gwalior


# ///==========Libraries, Constants and Functions=============///


import sys


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


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


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

# ///==========MAIN=============///


def main():
    p = get_array()
    p.sort()
    a, b, c, d = p[0], p[1], p[2], p[3]
    z = d - a
    y = d - b
    x = d - c
    print(x, y, z)


def __starting_point():
    main()

__starting_point()

x = sorted(map(int, input().split()))
print("%d %d %d"%(x[-1]-x[0], x[-1]-x[1], x[-1]-x[2]))


n = [int(x) for x in input().split()]
m = max(n)
n.remove(m)
print(' '.join(str(m - x) for x in n))


c, b, a, d = sorted(list(map(int, input().split())))
print(d-a, d-b, d-c)

a = list(map(int,input().split()))
a.sort()
print(a[3]-a[2],a[3]-a[1],a[3]-a[0])


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


x = max(a, b, c, d)

if x == a:
	print(x - b, x - c, x - d)
elif x == b:
	print(x - a, x - c, x - d)
elif x == c:
	print(x - b, x - a, x - d)
elif x == d:
	print(x - b, x - c, x - a)



import math
import bisect
import itertools
import sys
I=lambda : sys.stdin.readline()
mod=10**9 +7
'''fact=[1]*100001
ifact=[1]*100001
for i in range(1,100001):
    fact[i]=((fact[i-1])*i)%mod
    ifact[i]=((ifact[i-1])*pow(i,mod-2,mod))%mod
def ncr(n,r):
    return (((fact[n]*ifact[n-r])%mod)*ifact[r])%mod
def npr(n,r):
    return (((fact[n]*ifact[n-r])%mod))
    '''

def modu(a,m):
    if a%m:
        return a%m
    return m

def mindiff(a):
    b=a[:]
    b.sort()
    m=10000000000
    for i in range(len(b)-1):
        if b[i+1]-b[i]<m:
            m=b[i+1]-b[i]
    return m
    
def lcm(a,b):
    return a*b//math.gcd(a,b)

    
def merge(a,b):
    i=0;j=0
    c=0
    ans=[]
    while i<len(a) and j<len(b):
        if a[i]<b[j]:
            ans.append(a[i])
            i+=1
        else:
            ans.append(b[j])
            c+=len(a)-i
            j+=1
    ans+=a[i:]
    ans+=b[j:]
    return ans,c
def mergesort(a):
    if len(a)==1:
        return a,0
    mid=len(a)//2   
    left,left_inversion=mergesort(a[:mid])
    right,right_inversion=mergesort(a[mid:])
    m,c=merge(left,right)
    c+=(left_inversion+right_inversion)
    return m,c
    
def is_prime(num):
    if num == 1: return False
    if num == 2: return True
    if num == 3: return True
    if num%2 == 0: return False
    if num%3 == 0: return False
    t = 5
    a = 2
    while t <= int(math.sqrt(num)):
        if num%t == 0: return False
        t += a
        a = 6 - a
    return True
    
  
def ceil(a,b):
    if a%b==0:
        return a//b
    else:
        return (a//b + 1)


def ncr1(n,r):
    s=1
    for i in range(min(n-r,r)):
        s*=(n-i)
        s%=mod
        s*=pow(i+1,mod-2,mod)
        s%=mod
    return s


#/////////////////////////////////////////////////////////////////////////////////////////////////

a=list(map(int,input().split()))
a.sort()
print(a[-1]-a[0],a[-1]-a[1],a[-1]-a[2])