Problem:
 Score : 100 points    Problem Statement You have decided to give an allowance to your child depending on the outcome of the game that he will play now.  The game is played as follows:   There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a + printed on it.  The player should construct a formula of the form X + Y , by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)  Then, the amount of the allowance will be equal to the resulting value of the formula.   Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.      Constraints  All values in input are integers.  1 \leq A, B, C \leq 9         Input Input is given from Standard Input in the following format:  A  B  C       Output Print the maximum possible amount of the allowance.        Sample Input 1 1 5 2      Sample Output 1 53  The amount of the allowance will be 53 when the panels are arranged as 52+1 , and this is the maximum possible amount.       Sample Input 2 9 9 9      Sample Output 2 108       Sample Input 3 6 6 7      Sample Output 3 82

Solution (Python):
A,B,C = map(int,input().split())

tmp = sorted([A,B,C],reverse = True)

print(tmp[0]*10+tmp[1]+tmp[2])

Solution (Python):
a,b,c = map(int, input().split())
ans1 = a * 10 + b + c
ans2 = a + b * 10 + c
ans3 = a + b + c * 10
ans = max(ans1,ans2,ans3)
print(ans)

Solution (Python):
import itertools
s = list(map(int, input().split()))
ss = list(itertools.permutations(s))
ans = 0
for i in ss:
    ans = max(ans, max(i[0]*10+i[1] + i[2], i[0]+i[1]*10 + i[2]))
print(ans)

Solution (Python):
numlist = sorted(list(map(int,input().split())),reverse = True)
print(int("".join(map(str,numlist[:2])))+numlist[-1])

Solution (Python):
a = list(map(int, input().split()))
a.sort();
print(a[0] + a[1] + a[2]*10)

Solution (Python):
n = list(map(str, input().split()))
n.sort(reverse=True)
base = n[0]+n[1]
ans = int(base)
print(ans + int(n[2]))

Solution (Python):
lis = list(map(int, input().split()))
lis.sort()
print(lis[2]*10 + lis[1] + lis[0])

Solution (Python):
hoge = [int(i) for i in input().split()]
hoge.sort()
print(hoge[2]*10+hoge[1]+hoge[0])

Solution (Python):
L = list(map(int, input().split()))
L.sort(reverse=True)
print(L[0]*10+L[1]+L[2])

Solution (Python):
A, B, C = sorted(map(int, input().split()), reverse=True)
print(10 * A + B + C)

Solution (Python):
l=sorted(list(map(int,input().split())))
print(l[2]*10+l[1]+l[0])

Solution (Python):
a,b,c=map(int,input().split())
li=[]
li.append(a)
li.append(b)
li.append(c)
li.sort()
print(li[2]*10+li[1]+li[0])

Solution (Python):
List = [int(n) for n in input().split()]

sort = sorted(List)

print(sort[2] * 10 + sort[1] + sort[0])

Solution (Python):
num = list(map(int,input().split()))
num.sort(reverse=True)
print(num[0]*10+num[1]+num[2])

Solution (Python):


def main():
    na = list(map(int, input().split()))

    na.sort(reverse = True)


    print(na[0] * 10 + na[1] + na[2])


if __name__ == '__main__':
    main()

Solution (Python):
a, b, c = map(int, input().split())
print(max(a * 10 + b + c, b * 10 + a + c, c * 10 + b + a))

Solution (Python):
l = [int(i)for i in input().split()]
a =max(l)
print(sum(l) +9*a)

Solution (Python):
a=list(map(int,input().split()))
a.sort()
print((a[2]*10+a[1])+a[0])

Solution (Python):
a,b,c=[int(x) for x in input().split()]
print(max(a,b,c)*10+a+b+c-max(a,b,c))

Solution (Python):
A,B,C=(int(i) for i in input().split())
abc=sorted([A,B,C])[::-1]
print(10*abc[0]+abc[1]+abc[2])

Solution (Python):
""" AtCoder """

import sys
input = sys.stdin.readline

N = list(map(int, input().split()))

N.sort()

print(N[2]*10+N[1]+N[0])

Solution (Python):
data = list(map(int, input().split()))
data.sort(reverse=True)
print(data[0]*10+data[1]+data[2])

Solution (Python):
num=input().split()
A=max(num)
num.remove((max(num)))
B=max(num)
num.remove((max(num)))
C=max(num)
ans=int(A)*10+int(B)+int(C)
print(ans)

Solution (Python):
def main():
    abc = list(input().split())
    abc.sort(reverse=True)
    print(int(''.join(abc[:2])) + int(abc[2]))


main()

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

print(max(a,b,c)*10+min(a,b,c)+(a+b+c-max(a,b,c)-min(a,b,c)))

Solution (Python):
A = sorted([int(i) for i in input().split()])

print(A[2]*10 + sum(A[:2]))

Solution (Python):
A = [int(i) for i in input().split()]
maxA = max(A)
minA = min(A)
midA = sum(A) - maxA - minA

print(maxA*10 + minA + midA)

Solution (Python):
d = sorted([i for i in map(int, str(input()).split())])
print(d[2] * 10 + sum(d[0:2]))

Solution (Python):

a = map(int, input().split(' '));
b = sorted(a, reverse=True)
c = (10 * b[0] + b[1]) + b[2]
print(c)

Solution (Python):
abc = list(map(int,input().split()))
print(max(abc)*10+sum(abc)-max(abc))

Solution (Python):
abc = list(map(int,input().split()))
abc.sort()
print(abc[0]+int(str(abc[2])+str(abc[1])))

Solution (Python):
l=list(map(int,input().split()))
m=max(l)
print(m*10+sum(l)-m)

Solution (Python):
import itertools

values = map(int, input().split())
ps = list(itertools.permutations(values))

_max = 0
for p in ps:
    num1 = p[0] + (p[1] * 10 + p[2])
    num2 = (10 * p[0] + p[1]) + p[2]
    _max = max([_max, num1, num2])
print(_max)

Solution (Python):
a=list(map(int,input().split()))
a.sort()
print(a[2]*9+sum(a))

Solution (Python):
print((lambda l:l[2] * 10 + l[0] + l[1])(sorted(list(map(int, input().split())))))

Solution (Python):
A, B, C = map(int,input().split())

print(9*max(A,B,C) + A+B+C)

Solution (Python):
N = list(map(int,input().split()))
A = N[0]
B = N[1]
C = N[2]
Nmax = max(A,B,C)
answer = Nmax*10 - Nmax + A + B + C
print(answer)

Solution (Python):
A, B, C = sorted(input().split(), reverse = True)
print(int(A + B) + int(C))

Solution (Python):
a = list(map(int,input().split()))
a.sort(reverse=True)
print(a[0]*10+a[1]+a[2])

Solution (Python):
def main(lst):
    lst.sort()
    print(sum(lst)+9*lst[2])
lst=list(map(int,input().split()))
main(lst)

Solution (Python):
abc = list(map(int,input().split()))
abc.sort()
abc.reverse()
print(abc[0]*10+abc[1]+abc[2])

Solution (Python):
inputs = list(map(int, input().split()))
inputs.sort()
print(inputs[2] * 10 + inputs[1] + inputs[0])

Solution (Python):
a, b, c = map(int, raw_input().split(" "))

m = max(a, b, c)

print(str(m * 10 + a + b + c -m))

Solution (Python):
a,b,c = map(int,input().split())
B = max(a,b,c)
print(B*9+a+b+c)

Solution (Python):
arr = sorted(list(map(int,input().split())))
print(arr[2]*10+arr[1]+arr[0])

Solution (Python):
a, b, c = list(map(int, input().split()))

big = max([a,b,c])

print(sum([a,b,c]) + 9*big)

Solution (Python):
line = list(map(int, input().split()))
line.sort(reverse=True)
print(line[0]*10 + line[1] + line[2])

Solution (Python):
a,b,c=map(int,input().split())
print(max(a,b,c)*9+a+b+c)

Solution (Python):
x=sorted(input().replace(' ',''))
print(int(''.join(x[:-3:-1]))+int(x[0]))

Solution (Python):
li = list(map(int, input().split()))
li.sort()

ans = sum(li) + 9 * li[-1]

 
print(ans)

Solution (Python):
l=list(map(int,input().split()))
print(sum(l)+max(l)*9)

Solution (Python):
lst = []
a,b,c = map(int,input().split())
lst.append(a)
lst.append(b)
lst.append(c)

lst.sort()
A = str(lst[2]) +str(lst[1])
print(int(A)+lst[0])

Solution (Python):
A, B, C = [int(i) for i in input().split()]
print(max(A,B,C)*10+(A+B+C-max(A,B,C)))

Solution (Python):
x,y,z = input().split()
x=int(x) 
y=int(y)
z=int(z)
if (x>=y and x>=z):
    print(10*x + y + z)
if (x<y and y>=z):
    print(x+10*y+z)
if (x<z and y<z):
     print(x+y+10*z)

Solution (Python):
a = list(map(int, input().split()))
a.sort(reverse=True)
print(a[0]*10+a[1]+a[2])

Solution (Python):
A = [int(x) for x in input().split()]
A.sort()

ans = A[2] * 10 + A[1] + A[0]

print(ans)

Solution (Python):
A,B,C = map(int,input().split())
mx = max([A,B,C])
ans = mx * 9 + A + B + C
print(ans)

Solution (Python):
print(eval('+'.join(sorted(input()))+'*10'))

Solution (Python):
ABC = list(map(int, input().split()))

ABC = list(sorted(ABC)) 
print(10*ABC[2]+ABC[0]+ABC[1])

Solution (Python):
a = [int(i) for i in input().split()] 
b = sorted(a,reverse=True)
ans = 10*b[0]+b[1]+b[2]
print(ans)

Solution (Python):
X, Y, Z = map(int, input().split())
print(max(10*X+Y+Z, 10*Y+Z+X, 10*Z+X+Y))

Solution (Python):
A = list(map(int, input().split()))
A.sort()
print(10 * A[2] + A[0] + A[1])

Solution (Python):
a, b, c = map(int, input().split())
mx = max([a, b, c])
print(mx * 9 + a + b + c)

Solution (Python):
a, b, c =sorted(map(int, input().split()))
print(a + b + c * 10)

Solution (Python):
a, b, c = sorted(map(int, input().split()))
print(c*10 + b + a)

Solution (Python):
ABC = list(map(int, input().split()))
ABC.sort()
ABC = list(map(str, ABC))
print(int(ABC[2]+ABC[1])+int(ABC[0]))

Solution (Python):
x, y, z = map(int,input().split())
print(9*max(x,y,z)+x+y+z)

Solution (Python):
def main():
    xs = sorted(map(int, input().split()))
    print(xs[0] + xs[1] + xs[2] * 10)


if __name__ == '__main__':
    main()

Solution (Python):
s=list(map(int,input().split()))
s.sort(reverse=True)
print(10*s[0]+s[1]+s[2])

Solution (Python):
A, B, C = map(int, input().split())
print(max(A+(10*B+C), (10*A+B)+C, (10*C+A)+B))

Solution (Python):
a,b,c=map(int,input().split())
m = 0
m = max(m,a*10+b+c)
m = max(m,b*10+a+c)
m = max(m,c*10+a+b)
print(m)

Solution (Python):
a, b, c = map(int, input().split())
A=[]
A.append(a*10+b+c)
A.append(a+b*10+c)
A.append(a+b+c*10)
print(max(A))

Solution (Python):
a, b, c = sorted([int(x) for x in input().split()])[::-1]
print((a*10+b)+c)

Solution (Python):
n = list(map(int, input().split()))
n.sort(reverse=True)
print(n[0]*10 + n[1] + n[2])

Solution (Python):
a,b,c = map(int,input().split(" "))
count = 0
count += a + b + c
count += (max(a,b,c) * 10 - max(a,b,c))
print(count)

Solution (Python):
inputs = list(map(int, input().split()))

inputs.sort()

print(inputs[0] + inputs[1] + inputs[2] * 10)

Solution (Python):
def main():
    A, B, C = map(int, input().split())
    print(A + B + C + max(A, B, C) * 9)


if __name__ == "__main__":
    main()

Solution (Python):
numlist = list(map(int, input().split()))

numlist.sort(reverse=True)

print(int(numlist[0])*10 + int(numlist[1])+ int(numlist[2]))

Solution (Python):
A = list(map(int,input().split()))
A.sort()

print(A[0]+int(str(A[2])+str(A[1])))

Solution (Python):
a, b, c = map(int, input().split())
print(a + b + c + max(a, b, c) * 9)

Solution (Python):
s = list(map(int, input().split()))
print(sum(s)+max(s)*9)

Solution (Python):
M = list(map(int, input().split()))
M.sort()
print(M[2]*10+M[1]+M[0])

Solution (Python):
a = list(map(int, input().split()))
a.sort()

print(sum(a) + a[2] * 9)

Solution (Python):
A,B,C = map(int, input().split())
L = sorted([A,B,C])
print(10*L[2]+L[1]+L[0])

Solution (Python):
if __name__ == '__main__':
    l = [int(i) for i in input().split()]
    l = sorted(l, reverse=True)

    print(int(str(l[0]) + str(l[1])) + l[2])

Solution (Python):
A=list(input().split())
A.sort()
print(str(int(A[0])+int(A[2]+A[1])))

Solution (Python):
a = list(map(int, input().split()))
print(a.pop(a.index(max(a)))*10 + a.pop(a.index(max(a))) + a.pop(a.index(max(a))))

Solution (Python):
a=list(map(int,input().split()))
print(max(a)*9+sum(a))

Solution (Python):
li = list(map(int, input().split()))
li.sort()
print(li[-1] * 10 + li[1] + li[0])

Solution (Python):
import itertools
print(max([(int(i[0]) + int(i[1] + i[2])) for i in itertools.permutations(input().split())]))

Solution (Python):
l = sorted(list(map(int, input().split())))
print(l[2] * 10 + l[1] + l[0])

Solution (Python):
A, B, C = map(int, input().split())
X = max( [A+B+C*10, A+B*10+C, A*10+B+C] )
print(X)

Solution (Python):
a, b, c = list(map(int, input().split()))
print(max(a,b,c)*9 + (a+b+c))

Solution (Python):

S=input().split()
S=sorted(S, reverse=True)
print(int(S[0]+S[1])+int(S[2]))

Solution (Python):
num = list(input().split())

num.sort(reverse=True)

print(int(num[0]+num[1]) + int(num[2]))

Solution (Python):

A,B,C=map(int,input().split())
print(max(A*10+B+C, B*10+C+A,  C*10+A+B))

Solution (Python):
a=list(map(int,input().split()))
a.sort()
print(a[2]*10+a[1]+a[0])

Solution (Python):
list = list(map(int,input().strip().split()))
list.sort()
a ,b ,c = list
print(c*10 + a + b)

Solution (Python):



def main():
    """Function."""
    a = list(map(str, input().split()))
    a.sort(reverse=True)
    print(int(a[0]+a[2]) + int(a[1]))


if __name__ == "__main__":
    main()

Solution (Python):
a = list(map(int, input().split()))
m = max(a)
a.remove(m)
print(m*10+a[0]+a[1])

Solution (Python):
A,B,C=map(int,input().split())
L=sorted([A,B,C])
print(int(str(L[2])+str(L[1]))+L[0])

Solution (Python):


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

if __name__ == "__main__":
    n = read_int_n()
    ans = 0
    for i in range(3):
        n[i] *= 10
        sum = 0
        for k in n:
            sum += k
        if sum > ans:
            ans = sum
        n[i] /= 10
    print(int(ans))

Solution (Python):
num_list = [int(x) for x in input().split()]
num_list.sort(reverse = True)
print(num_list[0] * 10 + num_list[1] + num_list[2])

Solution (Python):
num = list(map(int, input().split()))
num.sort(reverse=True)
print(num[0] * 10 + num[1] + num[2])

Solution (Python):
list = list(map(str,input().split()))
list.sort(reverse=True)
A = list[0]+list[1]
B = list[2]
print(int(A)+int(B))

Solution (Python):
l = [i for i in input().split(" ")]
l.sort()
l.reverse()
print(int(''.join(l[0:2]))+int(l[2]))

Solution (Python):
li = [int(i) for i in input().split()]
li.sort(reverse=True)
print(li[0] * 10 + li[1] + li[2])

Solution (Python):
l = [int(n) for n in input().split()]
m = max(l)
mi = l.index(m)
ans = 0
for i in range(len(l)):
    if i == mi:
        ans += l[i] * 10
    else:
        ans += l[i]
print(ans)

Solution (Python):
l = list(map(int,input().split()))
l.sort(reverse=True)
print(l[0]*10+l[1]+l[2])

Solution (Python):
A = list(map(int,input().split()))
A.sort(reverse=True)
print(A[0]*10+A[1]+A[2])

Solution (Python):
n = list(map(int, input().split()))
n.sort(reverse=True)
print(10 * n[0] + n[1] + n[2])

Solution (Python):
a=sorted(list(map(int,input().split())))
print(int(str(a[2])+str(a[1]))+a[0])

Solution (Python):
import itertools

a=[i for i in input().split()]
b=list(itertools.permutations(a))
c='+'
ans=0
for i in range(len(b)):
    d=eval(b[i][0]+b[i][1]+c+b[i][2])
    if ans < d:
      ans=d
print(ans)

Solution (Python):
A, B, C = map(int, input().split())
f = (lambda a, b, c: 10*a+b+c)
l = [f(A, B, C), f(B, A ,C), f(C, A, B)]
print(max(l))

Solution (Python):
x_list = sorted(map(int, input().split()))
print(x_list[-1] * 10 + x_list[-2] + x_list[0])

Solution (Python):
a = list(map(int,input().split()))

a.sort()

print(a[2]*10+a[1]+a[0])

Solution (Python):
s = raw_input()
a,b,c = map(int, s.split(" "))
l=[a,b,c]
l.sort(reverse=True)
m = l[0] * 10 + l[1] + l[2]
print m

Solution (Python):
nums =[int(x) for x in input().split(" ")]

nums = sorted(nums, reverse=True)

print(nums[0]*10 + nums[1] + nums[2])

Solution (Python):
num = map(int , raw_input().split(" "))

snum = sorted(num, reverse=True)

print snum[0]*10 + snum[1]+ snum[2]

Solution (Python):



s = raw_input()
nums = [int(x) for x in s.split()]
nums = sorted(nums, reverse=True)
a, b, c = nums
print a*10+b+c

Solution (Python):

num = list(map(int, input().split()))

num[num.index(max(num))] *= 10

print(sum(num))

Solution (Python):

import numpy as np

num = list(map(int, input().split()))

num[num.index(max(num))] = max(num) * 10

print(np.sum(num))

Solution (Python):
l = list(map(int,input().split()))
print(sum(l)+9*max(l))

Solution (Python):
lst = sorted([x for x in input().split()], reverse=True)
print(int("".join(lst[:2])) + int(lst[2]))

Solution (Python):
a,b,c=sorted(map(int,input().split()));print(a+b+10*c)

Solution (Python):
A, B, C = map(int, input().split())
print(max(A, B, C)*10 + (A + B +C) - max(A, B, C))

Solution (Python):

n=[int(i) for i in input().split()]
n.sort()
print(n[2]*10+n[1]+n[0])

Solution (Python):
X = map(int, raw_input().split())
y = max(X)
print 10*y+sum(X)-y

Solution (Python):
A, B, C = map(int, input().split())
ans = [A * 10 + B + C, B * 10 + A + C, C * 10 + A + B]
print(max(ans))

Solution (Python):
l = list(map(int,input().split()))
print(sum(l) + 9*(max(l)))

Solution (Python):
A, B, C = map(int, input().split())
print(max(A, B, C) * 9 + A + B + C)

Solution (Python):

A,B,C = map(int,input().split())

if A >= B and A >= C :
    sum = A * 10 + B + C

elif B >= A and B >= C:
    sum = B * 10 + A + C
    
else:
    sum = C * 10 + A + B

print(sum)

Solution (Python):
A,B,C = sorted(list(map(int,input().split())))
print(A + B + C * 10)

Solution (Python):
n = sorted(list(map(int, input().split())), reverse=True)
print(n[0]*10 + n[1] + n[2])

Solution (Python):
a = [int(i) for i in input().split()]
a.sort()
a.reverse()
b = a[0]*10+a[1]+a[2]
print(b)

Solution (Python):
a, b, c = input().split()

print(max(int(a+b)+int(c), 
	int(a)+int(b+c), 
	int(a+c)+int(b),
	int(c+a)+int(b), 
	int(c+b)+int(a),
	int(b+a)+int(c)))

Solution (Python):
nums = list(map(int, input().split()))
nums.sort(reverse=True)
print(int(str(nums[0]) + str(nums[1])) + nums[2])

Solution (Python):
abc = list(map(int,input().split()))
abc.sort(reverse=True)
ans=abc[0]*10+abc[1]+abc[2]
print(ans)

Solution (Python):
x=[int(i) for i in input().split()] 

x.sort()
x.reverse()

print(x[0]*10+x[1]+x[2])

Solution (Python):
x=[int(i) for i in input().split()] 

x.sort()
x.reverse()

print(x[0]*10+x[1]+x[2])

Solution (Python):
def main():
    l = list(map(int, input().strip().split()))
    l.sort(reverse = True)
    print(l[0] * 10 + l[1] + l[2])

if __name__ == "__main__":
    main()

Solution (Python):
A = sorted(list(map(int, input().split())))
print(A[2] * 10 + A[1] + A[0])

Solution (Python):

def solve():
    low, mid, high = sorted(list(map(str, input().split())))
    print(int(high + mid) + int(low))


if __name__ == '__main__':
    solve()

Solution (Python):
D = list(map(int, input().split()))
print(max(D)*10+sum(D)-max(D))

Solution (Python):
a=input().strip().split(" ")
b=[int(i) for i in a]

b.sort()

print(b[2]*10+b[1]+b[0])

Solution (Python):
a, b, c = map(int, input().split())
x = a*10 + b + c
y = b*10+ c + a
z = c*10+ a + b
print(max([x, y,z]))

Solution (Python):
a=list(map(int,input().split()))
a.sort(reverse=True)
print(a[0]*10+a[1]+a[2])

Solution (Python):
l=list(map(int,input().split()))
l=sorted(l,reverse=True)
print(l[0]*10+l[1]+l[2])

Solution (Python):
N = list(map( int, input().split()))

N = sorted(N)

Nmax = int( N[2] * 10 + N[1] + N[0])

print(int(Nmax))

Solution (Python):
N = list(map(int, input().split()))
N = sorted(N)
print(N[2]*10 + N[1] + N[0])

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

s1 = 10 * a + b + c
s2 = a + 10 * b + c
s3 = a + b + 10*c

print(max(s1, s2, s3))

Solution (Python):
A = list(map(int, input().split()))
A.sort(reverse = True)
print(int(str(A[0]) + str(A[1])) + A[2])

Solution (Python):
N = input().split()
N.sort()

Nmax = N[2] + N[1]
print(int(Nmax) + int(N[0]))

Solution (Python):
def maximize_the_formula(a, b, c):
    l = sorted([a, b, c])
    return l[2] * 10 + l[1] + l[0]

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

Solution (Python):
a = sorted(list(map(int,input().split())))
print(int(str(a[-1])+str(a[-2])) + a[0])

Solution (Python):
a,b,c=[int(i) for i in input().split()]
print(max(a,b,c)*9+a+b+c)

Solution (Python):
a,b,c = sorted(list(map(int, input().split())))
print(c*10+b+a)

Solution (Python):

numbers = [int(i) for i in input().split()]

left1 = max(numbers)
numbers.remove(left1)
left2 = max(numbers)
right = min(numbers)

left = str(left1) + str(left2)

print(int(left) + right)

Solution (Python):
l = list(map(int, input().split()))
m = max(l)
l.remove(m)
print(m * 10 + max(l) + min(l))

Solution (Python):
a,b,c=list(map(int,input().split()))
print(max(10*a+b+c, a+10*b+c, a+b+10*c))

Solution (Python):
def bogosort(l):
  import random
  while 1:
    random.shuffle(l)
    for i in range(1,len(l)):
      if l[i]<l[i-1]:
        break
    else:
      return l
l=input().split()
a,b,c=bogosort(l)
print(eval(c+b+'+'+a))

Solution (Python):
s=sorted(input())[::-1]
s.insert(2,'+')
print(eval(''.join(s)))

Solution (Python):
*_,a,b,c=sorted(input());print(eval(c+b+'+'+a))

Solution (Python):
*h,a,b,c=sorted(input());print(int(c+b)+int(a))

Solution (Python):
h,f,a,b,c=sorted(input());print(int(c+b)+int(a))

Solution (Python):
a,b,c=sorted(input()[::2]);print(int(c+b)+int(a))

Solution (Python):
a,b,c=sorted(input().split());print(int(c+b)+int(a))

Solution (Python):
a,b,c = map(int,input().split())
if max(a,b,c) == a:
    n = a*10+b+c
    print(n)

elif max(a,b,c) == b:
    n = b*10+a+c
    print(n)

else:
    n = c*10+a+b
    print(n)

Solution (Python):
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b



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



def lcm(a, b):
    g = gcd(a, b)
    return a / g * b


def main():
    l = list(sorted(list(map(int, input().split()))))
    print(l[-1] * 10 + l[0] + l[1])


if __name__ == '__main__':
    main()

Solution (Python):
abc = list(map(int, input().split()))
abc.sort()
print(abc[0] + abc[1] + abc[2] * 10)

Solution (Python):
A = list(map(int, input().split()))
A.sort(reverse=True)
print(A[0]*10+A[1]+A[2])

Solution (Python):
def abc110_a():
    abc = list(map(int, input().split()))
    abc.sort()
    return abc[2] * 10 + abc[1] + abc[0]


print(abc110_a())

Solution (Python):
nums = list(map(int, input().split()))

nums.sort()

print(nums[2] * 10 + nums[1] + nums[0])

Solution (Python):
sa = input().split()

sa.sort()

ans = int(sa[2] + sa[1]) + int(sa[0])
print(ans)

Solution (Python):


sa = input().rstrip().split()
sa.sort()

ans = int(sa[0]) + int(sa[2] + sa[1])
print(ans)

Solution (Python):
a = input().split()
b = sorted(a, key = int)
print(int(b[2]+ b[1]) + int(b[0]))

Solution (Python):
A = list(map(int,input().split()))
A.sort(reverse=True)
print(A[0]*10+A[1]+A[2])

Solution (Python):
import sys


def main():
    a = list(map(int, input().split()))
    a.sort()
    ans = a[0] + a[1] + 10*a[2]
    print(ans)


main()

Solution (Python):
a,b,c = map(int,input().split())
if a>=b:
    if a>=c:
        print(a*10+b+c)
    else:
        print(c*10+a+b)
else:
    if b>=c:
        print(b*10+a+c)
    else:
        print(c*10+a+b)

Solution (Python):
a,b,c=map(int,input().split())
print(max([a,b,c])*10+a+b+c-max([a,b,c]))

Solution (Python):
a = input().split()
a.sort()
b = int(a[2] + a[1])
print(int(a[0]) + b)

Solution (Python):
A=list(map(int,input().split()))
A=sorted(A)
print(int(A[0])+10*(int(A[2]))+int(A[1]))

Solution (Python):
a,b,c = map(int, input().split())
i = int(str(a)+str(b))+c
i2= int(str(b)+str(a))+c
j = int(str(b)+str(c))+a
j2= int(str(c)+str(b))+a
k = int(str(c)+str(a))+b
k2= int(str(a)+str(c))+b
n = max(i,i2,j,j2,k,k2)
print(n)

Solution (Python):
A, B, C = list(map(int, input().split()))

ans = A + B + C + 9 * max(A, B, C)

print(ans)

Solution (Python):
a=list(map(int,input().split()))
a.sort()
print(10*a[-1]+a[0]+a[1])

Solution (Python):

A,B,C=input().split(' ')



A=int(A)
B=int(B)
C=int(C)
numberList=[A,B,C]

numberList.sort(reverse=True)

sum=0
sum=numberList[0]*10+numberList[1]+numberList[2]

print(sum)

Solution (Python):
x,y,z=(int(x) for x in input().split())
a = [x,y,z]
a = sorted(a)
print(a[2]*10+a[1]+a[0])

Solution (Python):
a = list(input().split())
a.sort()
a.reverse()
b = a[0] + a[1]
print(int(b) + int(a[2]))

Solution (Python):
a = sorted(list(map(int, input().split())))
print(a[2] * 10 + a[1] + a[0])

Solution (Python):
a = list(int(i) for i in input().split())
a.sort()
print(10*a[2]+a[1] + a[0])

Solution (Python):
def big(a, b, c):
    if a>=b and a>=c:
        g = a
    elif b>=a and b>=c:
        g = b
    else:
        g = c

    return g


n = list(map(int, input().split()))

a, b, c = n[0], n[1], n[2]
g1, g2 = 0, 0

g1 = big(a, b, c)
if g1 == a:
    a = 0
elif g1 == b:
    b = 0
else:
    c = 0

g2 = big(a, b, c)
if g2 == a:
    a = 0
elif g2 == b:
    b = 0
else:
    c = 0

num = g1*10 + g2 + a + b + c

print(num)

Solution (Python):
lst = sorted(input().split(), reverse=True)
print(int(lst[0] + lst[1]) + int(lst[2]))

Solution (Python):
suuji = list(map(int, input().split()))
saidai = max(suuji)
suuji.remove(saidai)
print(saidai*10+suuji[0]+suuji[1])

Solution (Python):
li_a = list(map(int, input().split()))
ans = max(li_a) * 10
li_a.remove(max(li_a))
ans += sum(li_a)
print(ans)

Solution (Python):
n_list = map(int, input().split())
n_list_rev = sorted(n_list, reverse=True)
print(10 * n_list_rev[0] + n_list_rev[1] + n_list_rev[2])

Solution (Python):
a = list(map(int,input().split(" ")))
x10 = max(a)
a.remove(x10)

s = x10 * 10 + a[0] + a[1]
print(s)

Solution (Python):
a, b, c = map(int, raw_input().split())

print max(10*a+b+c,10*b+a+c,10*c+a+b)

Solution (Python):
a, b, c = map(int, raw_input().split())

print max(10*a+b+c, a+10*b+c, 10*c+a+b)

Solution (Python):
l = list(map(int, input().split()))
l.sort(reverse=True)
print(l[0]*10 + l[1] + l[2])

Solution (Python):



def solve(numbers):
    return max(
        int(numbers[0] + numbers[2]) + int(numbers[4]),
        int(numbers[2] + numbers[4]) + int(numbers[0]),
        int(numbers[4] + numbers[0]) + int(numbers[2]),
    )


if __name__ == "__main__":
    print(solve(input("")))

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

A = 10*a + b + c
B = a + 10*b + c
C = a + b + 10*c

print(max([A, B, C]))

Solution (Python):
A,B,C=map(int,input().split())
arr=[]
if((A>=1 and A<=9)and(B>=1 and B<=9)and(C>=1 and C<=9)):
    arr=[A,B,C]
    arr=sorted(arr, reverse=True)
    mystr=str(arr[0])+str(arr[1])
    print(int(mystr)+arr[2])

Solution (Python):
li = list(map(int,input().split()))
li.sort()

print(li[2]*10+li[1]+li[0])

Solution (Python):
x=list(map(int,input().split()))
x.sort(reverse=True)
print(x[0]*10+x[1]+x[2])

Solution (Python):
a = list(map(int,input().split()))
a.sort()
a.reverse()
print(a[0]*10+a[1]+a[2])

Solution (Python):
e = [int(_) for _ in input().split()]
print(max(e) * 10 + sum(e) - max(e))

Solution (Python):
list_ = sorted(input(), reverse=True)
print(int("".join(list_[:2])) + int(list_[2]))

Solution (Python):
n = list(map(int,input().split()))
n.sort()
print(n[2]*10+n[1]+n[0])

Solution (Python):
n = list(map(int,input().split()))
n.sort()
n.reverse()
print(n[0]*10+n[1]+n[2])

Solution (Python):
a, b, c = [int(i) for i in input().split()]
n = sorted([a, b, c], reverse=True)
print(10*n[0] + n[1] + n[2])

Solution (Python):
a = list(map(int, input().split()))
print(max(a)*9+sum(a))

Solution (Python):
l=list(map(int,input().split()))
l2=sorted(l)
print(10*l2[2]+l2[1]+l2[0])

Solution (Python):
lst = (raw_input().split())


lst.sort()
lst.reverse()
lst = list(map(int, lst))



ans = 10*lst[0] + lst[1] + lst[2]
print(ans)

Solution (Python):
a = list(map(int, input().split()))
a.sort(reverse=True)
print(a[0]*10+a[1]+a[2])

Solution (Python):

list= [int(i) for i in input().split()] 
l=sorted(list)
l[-1]=l[-1]*10
print(sum(l))

Solution (Python):
x = list(map(int, input().split()))
x = sorted(x, reverse=True)
print(x[0]*10 + x[1] + x[2])

Solution (Python):
import sys



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

if(b <= c and a <= c):
    print(10*c + a + b)
elif(a <= b and c <= b):
    print(10*b + c + a)
elif(c <= a and b <= a):
    print(10*a + c + b)

Solution (Python):
A = [i for i in input().split()]
A = sorted(A, reverse=True)

B = A[0]+A[1]
C = A[2]
ans = int(B) + int(C)

print(ans)

Solution (Python):
a,b,c=map(int,input().split())
ans=[]
ans.append(a)
ans.append(b)
ans.append(c)
ans.sort(reverse=True)
temp=""
temp+=str(ans[0])
temp+=str(ans[1])
print(int(temp)+ans[2])

Solution (Python):
a = list(map(int,input().split()))
a = sorted(a)
print(a[2] * 10 + a[1] + a[0])

Solution (Python):
*a,=sorted(map(int,input().split()))
print(a[0]+a[1]+a[2]*10)

Solution (Python):
n = list(map(int, input().split()))
n.sort(reverse=True)
max = str(n[0]) + str(n[1])
max = int(max) + n[2]

print("{}".format(max))

Solution (Python):
l=list(map(int,input().split()))
l.sort(reverse=True)
print(l[0]*10+l[1]+l[2])

Solution (Python):


n  = list(map(int, input().split()))
n.sort(reverse=True)
print(n[0]*10+n[1]+n[2])

Solution (Python):
a,b,c = map(int, input().split())
print(9*max(a,b,c)+a+b+c)

Solution (Python):
R=list(map(int,input().split()))
R.sort(reverse=True)
ans=10*R[0]+R[1]+R[2]
print(ans)

Solution (Python):
a,b,c = map(int, input().split())
print(max(a, b, c) * 10 + a + b + c - max(a, b, c))

Solution (Python):
A, B, C = map(int,input().split())
ans = max([A*10+B+C,A+B*10+C,A+B+C*10])
print(ans)

Solution (Python):
n = input().split()

n.sort()

print(int(n[0])+int(n[2]+n[1]))

Solution (Python):
a = list(map(int,input().split()))
a.sort()
print(10*a[2]+a[1] + a[0])

Solution (Python):

list1 = list(map(int, input().split()))
list1.sort()
print(10*list1[2]+list1[1]+list1[0])

Solution (Python):
l = list(map(int,input().split()))
l.sort()
print(int(str(l[2])+str(l[1]))+l[0])

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

if a >= b and a >= c:
    print(a*10 + b + c)
elif b >= a and b >= c:
    print(b*10 + a + c)
else:
    print(c*10 + a + b)

Solution (Python):
x=list(map(int,input().split()))

x.sort()
print(int(str(x[-1])+str(x[1]))+x[0])

Solution (Python):
A, B, C = map(int,input().split())

a = [A, B, C]
a.sort()

print((10 * a[2] + a[1] + a[0]))

Solution (Python):
def bSort(a):
    for i in range(len(a)):
        for j in range(len(a)-1, i, -1):
            if a[j] < a[j-1]:
                a[j], a[j-1] = a[j-1], a[j]

    return a

ns = input().split()
s = bSort(ns)
print(int(s[2]) * 10 + int(s[1]) + int(s[0]))

Solution (Python):
a = list(map(int,input().split()))
a.sort()
b = a[2]*10
print(b+a[1]+a[0])

Solution (Python):
A,B,C = map(int,input().split())
X = []
Y = []
if A >= B and A >= C:
    X.append(str(A))
    if B >= C:
        X.append(str(B))
        Y.append(str(C))
    else:
        X.append(str(C))
        Y.append(str(B))

elif B >= A and B >= C:
    X.append(str(B))
    if A >= C:
        X.append(str(A))
        Y.append(str(C))
    else:
        X.append(str(C))
        Y.append(str(A))

else:
    X.append(str(C))
    if A >= B:
        X.append(str(A))
        Y.append(str(B))
    else:
        X.append(str(B))
        Y.append(str(A))
ans = int((''.join(X))) + int((''.join(Y)))
print(ans)

Solution (Python):
a,b,c=map(int,input().split())
print(max(a,b,c)*9+a+b+c)

Solution (Python):
li = list(map(int, input().split()))
li.sort()
print(li[2]*10+li[0]+li[1])

Solution (Python):
a, b, c = map(int, raw_input().split())
print a + b + c + 9 * max(a, b, c)

Solution (Python):
a, b, c=input().split()
matome=[a,b,c]
mx=max(a,b,c)
mn=min(a,b,c)
mex=mx+mn
ans1=int(mex)
import statistics
md=statistics.median(matome)
ans2=int(md)
print(ans1+ans2)