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):
X, Y, Z = sorted(map(int,input().split()))
print(X+Y+10*Z)

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

print(10*C+B+A)

Solution (Python):
ni = lambda: int(input())
nl = lambda: list(map(int, input().split()))
nm = lambda: map(int, input().split())

l = nl()

sl = sorted(l)[::-1]

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

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

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

l = [A,B,C]

for i in range(3):
  if ans < (10*l[i%3] + l[(i+1)%3] + l[(i+2)%3]):
    ans = 10*l[i%3] + l[(i+1)%3] + l[(i+2)%3]

print(ans)

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

l = [A,B,C]
sort_l = sorted(l)

sort_l_str = str(sort_l[2])+str(sort_l[1])

sort_l_int = int(sort_l_str)

print(sort_l[0]+sort_l_int)

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

M=[A,B,C]
U=max(M)
M.remove(max(M))
P=U*10+sum(M)

print(P)

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

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

Solution (Python):
s = [int(x) for x in input().split()]
max_int = s.pop(s.index(max(s)))
print(max_int * 10 + sum(s))

Solution (Python):
num = sorted(map(int,input().split()))[::-1]

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

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

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

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

Solution (Python):
from itertools import permutations
from copy import copy

choices = list(map(int, input().split()))
combs = permutations(choices, 2)

res = 0

for comb in combs:
    left = copy(choices)
    for num in comb:
        left.remove(num)
    right = int(str(comb[0]) + str(comb[1]))
    total = left[0] + right
    if total > res:
        res = total

print(res)

Solution (Python):
number = list(map(str, input().split()))

number.sort()

print(int(number[-1] + number[-2]) + int(number[0]))

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

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

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

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

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

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

Solution (Python):
if __name__ == '__main__':
    ABC = list( map(int, input().split()))
    ABC.sort()
    num = ABC.pop()*10 + ABC.pop() + ABC.pop()
    print(num)

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

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

Solution (Python):
a,b,c=map(str,input().split())
ans = max(int(a+b)+int(c),int(a)+int(b+c))
hoge = max(int(b+a)+int(c),int(a)+int(c+b))
fuga = max(int(b)+int(a+c),int(b)+int(c+a))

print(max(max(ans,hoge),fuga))

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

a.sort()

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

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

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

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

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

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

Solution (Python):
S = list(input().split())
S.sort(reverse=True)
a = int("".join(S[:2]))
b = int(S[2])
print(a+b)

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

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

s = a + int(str(b)+str(c))
t = c + int(str(b)+str(a))
u = b + int(str(c)+str(a))
v = a + int(str(c)+str(b))
w = c + int(str(a)+str(b))
x = b + int(str(a)+str(c))

print(max(s,t,u,v,w,x))

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

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

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

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

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

Solution (Python):
S = list(map(int, input().split()))
A = max(S)
S.remove(A)
B = max(S)
S.remove(B)
C = S.pop()
print(int(str(A) + str(B)) + C)

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

Solution (Python):

A = list(map(int,input().split()))
A_new=sorted(A,reverse=True)
A2=str(A_new[0])+str(A_new[1])
ans = int(A2)+ A_new[2]
print(ans)

Solution (Python):
arr = [int(x) for x in input().split()]
s_arr = sorted(arr)
print(s_arr[2]*10+s_arr[1]+s_arr[0])

Solution (Python):
l = sorted(map(int,input().split()),reverse=True)
print(eval(''.join(map(str,l[:2]))+'+'+str(l[2])))

Solution (Python):


def main():
    
    V = sorted(map(int, input().split()),reverse=True)
    print(10*V[0]+V[1]+V[2])
        
if __name__ == '__main__':
    main()

Solution (Python):
a,b,c = sorted([int(i) for i in input().split()],reverse = True)

print(10*a + b + c)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print(c*10 + b + a)

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 = list(map(int, input().split()))
n.sort()

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

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

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

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

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

Solution (Python):

import sys


def solve(A: int, B: int, C: int):
    l = [A, B, C]
    if max(l) == A:
        print(A * 10 + B + C)
    elif max(l) == B:
        print(A + B * 10 + C)
    else:
        print(A + B + C * 10)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    C = int(next(tokens))  
    solve(A, B, C)

if __name__ == '__main__':
    main()

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

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

Solution (Python):
import sys
input = sys.stdin.readline

S = list(map(str, input().split()))

ans = 0
for i in range(3):
    for j in range(3):
        for k in range(3):
            if i==j or j==k or k==i: continue
            a=S[i]
            b=S[j]+S[k]
            ans=max(ans,int(a)+int(b))
print(ans)

Solution (Python):
s=list(input().split())
s.sort()
min=int(s[0])
max=int(s[2]+s[1])
total=max+min
print(total)

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

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

Solution (Python):
import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
l=list(map(int,input().split()))

ls=sorted(l)

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

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

Solution (Python):
A_list = list(map(int, input().split()))
A_list.sort(reverse=True)

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

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

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

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

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

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

d = max(int(a+b)+int(c),int(a+c)+int(b),
int(b+a)+int(c),int(b+c)+int(a),
int(c+a)+int(b),int(c+b)+int(a))

print(d)

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

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

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

print(ans)

Solution (Python):
a, b, c = map(int, input().split())
s = sorted([a, b, c], reverse=True)
print(int(str(s[0]) + str(s[1])) + s[2])

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

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

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

buf.sort()

print(max(buf)*10+buf[1]+buf[0])

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

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

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

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

Solution (Python):
A  = list(map(int, input().split()))
A = sorted(A)
A = A[::-1]

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

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

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

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

Solution (Python):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
abc = list(sorted(map(str, input().split())))

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

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

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

Solution (Python):


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

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

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

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

Solution (Python):
n = input().split()
n = [int(n[i]) for i in range(len(n))]
n.sort()
n = n[::-1]

total = ''
for i in range(len(n)):
    if i == 0 or i == 1:
        total += str(n[i])
    else:
        total += '+'
        total += str(n[i])
print(eval(total))

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

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

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

Solution (Python):
def main():
    a, b, c = input().split()
    ans = 0
    ans = max(ans, int(a)+int(b+c))
    ans = max(ans, int(a)+int(c+b))
    ans = max(ans, int(b)+int(a+c))
    ans = max(ans, int(b)+int(c+a))
    ans = max(ans, int(c)+int(a+b))
    ans = max(ans, int(c)+int(b+a))
    print(ans)

if __name__ == "__main__":
    main()

Solution (Python):

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

Solution (Python):
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

li = na()
print(sum(li) + max(li) * 9)

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

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

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

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

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

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

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

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

Solution (Python):


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

abc.sort(reverse = True)

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

Solution (Python):
print(eval('{}{}+{}'.format(*sorted(list(map(int, input().split())))[::-1])))

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

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

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

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

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

card = [a, b, c]
card.sort()
print(10*card[-1] + card[0] + card[1])

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

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


if __name__ == '__main__':
    func()

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


if __name__ == '__main__':
    func()

Solution (Python):
def func():
    A, B, C = map(str, input().split())
    cand1 = int(A + B) + int(C)
    cand2 = int(B + C) + int(A)
    cand3 = int(A + C) + int(B)
    cand4 = int(B + A) + int(C)
    cand5 = int(C + B) + int(A)
    cand6 = int(C + A) + int(B)
    print(max(cand1, cand2, cand3, cand4, cand5, cand6))


if __name__ == '__main__':
    func()

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

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

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

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

print(ans)

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

Solution (Python):

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


x = a * 10 + b + c
y = a + b * 10 + c
z = a + b + c * 10

print(max(x, y, z))

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

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

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

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

Solution (Python):
a, b, c = map(int, input().split())
if 1 <= a or b or c <= 9:
    print(max(10 * a + b + c, 10 * b + a + c, 10 * c + a + b))
else:
    print('hoge!')

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

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

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

x = str(a[-1]) + str(a[-2])

print(a[0] + int(x))

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

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

N_sort = sorted(N)

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

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

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

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

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

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

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

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

Solution (Python):
a=sorted(list(map(int,input().split())))
print(a[0]+a[1]+10*a[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 = sorted(map(int,input().split()))
print(a+b+10*c)

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

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

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

    sort_A = sorted(A, reverse=True)
    ans = int(str(sort_A[0]) + str(sort_A[1])) + sort_A[2]
    print(ans)

main()

Solution (Python):
a,b,c=map(int,input().split())
inputs=[a,b,c]
sorted_inputs=sorted(inputs,reverse=True)

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

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

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

Solution (Python):
def main():
    A, B, C = map(int, input().split())
    v = max([A, B, C])
    if v == A:
        return 10*A+B+C
    elif v == B:
        return 10*B+A+C
    else:
        return 10*C+A+B

if __name__ == '__main__':
    print(main())

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

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

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

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

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

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

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

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

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

max_num = max([a, b, c])
if a == max_num:
    print(a * 10 + b + c)
elif b == max_num:
    print(b * 10 + c + a)
else:
    print(c * 10 + a + b)

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

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)
elif (b>=c):
    print(b * 10 + a + c)

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

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

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

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

Solution (Python):


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

print(c * 10 + b + a)

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

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

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

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

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

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

print(List[-1]*10+List[-2]+List[0])

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

A.sort(reverse=True)

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

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

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

print(a*10+b+c)

Solution (Python):
import math
import sys
import queue
from collections import Counter
from itertools import accumulate
from fractions import gcd
from functools import reduce


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

def combination_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

sys.setrecursionlimit(10000)

mod = 1000000007

"""

a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654


char_list = list("abcd") 



    = sys.stdin.readline().rstrip()
    = list(sys.stdin.readline().rstrip())


    = int(sys.stdin.readline())
    = map(int, sys.stdin.readline().split())
    = list(map(int, sys.stdin.readline().split()))
    = [list(map(int,list(sys.stdin.readline().split()))) for i in range(N)]
"""

if __name__ == "__main__":
    L = sorted(list(map(int, sys.stdin.readline().split())), reverse=True)
    print(10 * L[0] + L[1] + L[2])

Solution (Python):

A = map(int, input().split())
A = sorted(A, reverse=True)

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import itertools


def solve():
    a, b, c = input().split()
    v = itertools.permutations([a, b, c], 3)
    max_a = 0
    for e1, e2, e3 in v:
        a = max(eval(e1 + "+" + e2 + e3), eval(e1 + e2 + "+" + e3))
        if a > max_a:
            max_a = a
    return max_a


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

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

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

Solution (Python):
import sys
from fractions import gcd
import bisect
 
stdin = sys.stdin
 
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
s = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]

num = na()
num.sort(reverse=True)
print(int(str(num[0])+str(num[1])) + num[2])

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

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

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

v.sort(reverse=True)
print(v[0] * 10 + v[1] + v[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(10*A + B + C, 10*B + C + A, 10 * C + A + B))

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

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

Solution (Python):
a=list(map(int,input().split()))
a.sort()
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):
a = list(map(int, input().split()))
a.sort()
print(sum(a)+9*a[2])

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

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

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

R = C*10
result = (R+B)+A

print(result)

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

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

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

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

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

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

print(10*a+b+c)

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

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

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

Solution (Python):

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

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

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

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

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

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

Solution (Python):
def test():
    a = list(map(int,input().split()))
    b = str(max(a))
    a.remove(max(a))
    c = str(max(a))
    d = int(b+c)
    print(d+int(min(a)))


if __name__ == "__main__":
    test()

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

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

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

Solution (Python):
import math





inputa = input().split()


inputa = [int(n) for n in inputa]
inputa.sort()

a = int(inputa[0])
b = int(inputa[1])
c = int(inputa[2])




print(c * 10 + a + b)

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

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

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

if max(A,B,C)==A:
    print(A*10+B+C)
elif max(A,B,C)==B:
    print(B*10+A+C)
elif max(A,B,C)==C:
    print(C*10+B+A)

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

x.sort(reverse=True)
print(x[0]*10+x[1]+x[2])

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

print(c*10 + b + a)

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

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

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

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

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

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

Solution (Python):
A,B,C=sorted([int(s) for s in input().split()])

print(10*C+B+A)

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

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

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

Solution (Python):
a,b,c=map(int,input().split())
print(max(a,b,c)*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):
money = list(map(int, input().split()))
money.sort(reverse=True)
print(int(str(money[0]) + str(money[1])) + money[2])

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

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

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

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

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

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

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