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):
def main():
    abc = list(map(int, input().split()))
    abc.sort(reverse=True)
    ans = int(str(abc[0]) + str(abc[1])) + abc[2]
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):

nums = [int(str) for str in input().strip().split()]

max_num = nums.pop(nums.index(max(nums)))

print(max_num * 10 + sum(nums))

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

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

A.sort()

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

Solution (Python):
a, b, c = map(int,input().split())
if a == max(a,b,c):
  print(int(str(a)+str(b))+c)
elif b == max(a,b,c):
  print(int(str(b)+str(c))+a)
else:
  print(int(str(c)+str(a))+b)

Solution (Python):

num=list(map(int,input().split()))
l=max(num)
s=min(num)
m=sum(num)-l-s
ans=int(str(l)+str(m))+s
print(ans)

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

Solution (Python):
A, B, C = map(int, input().split())
D = [A, B, C]
S = max(D)

ans = 0
l = 0
for i in range(3):
  if (D[i] == S) and (l == 0):
    ans += 10 * D[i]
    l = 1
  else:
    ans += D[i]
    
print(ans)

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=sorted(map(int,input().split()))
print(a+int(str(c)+str(b)))

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

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

Solution (Python):
a,b,c = map(int,input().split())
d = [a,b,c]
d.sort(reverse=True)
ans = ""
for i in range(2):
    ans += str(d[i])
print(int(ans) + d[-1])

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

Solution (Python):
import sys
import os


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    abc = list(map(str, sys.stdin.readline().split()))
    abc.sort(reverse=True)
    print(int(abc[0]+abc[1])+int(abc[2]))


if __name__ == '__main__':
    main()

Solution (Python):

a,b,c=list(input().split())
l=[]
l=sorted([a,b,c],reverse=True)
print(eval(l[0]+l[1]+"+"+l[2]))

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

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

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

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

print(10*c+b+a)

Solution (Python):
A,B,C = map(int,input().split())
D = []
D.append(A)
D.append(B)
D.append(C)
D = sorted(D,reverse=True)
E = max(int(str(D[0])+str(D[1]))+D[2],int(str(D[1])+str(D[2]))+D[0])
print(E)

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

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

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):
list = input().split()
list.sort(reverse=True)
a,b,c = list
A = int(a)*10 + int(b)
print( A + int(c))

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

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())))
ls=sorted(l,reverse=True)
print(ls[0]*10+ls[1]+ls[2])

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

Solution (Python):
ABC=list(map(int,input().split(' ')))
print(max([sum(ABC) + ABC[i]*9 for i in range(3)]))

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):
a=list(map(int,input().split()))
l=sorted(a,reverse=True)
max=str(l[0])+str(l[1])
print(int(max)+l[2])

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

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

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

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

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]
a,b,c = map(int,input().split(' '))
M = max(a,b,c)
T = a+b+c
print((T-M)+M*10)

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()

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

if __name__ == '__main__':
    main()

Solution (Python):
import sys
import os


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    a, b, c = sorted(map(str, sys.stdin.readline().split()))

    print(int("".join([c, b])) + int(a))


if __name__ == '__main__':
    main()

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

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

l.sort(reverse = True)
ans = int(str(l[0])+str(l[1])) + l[2]

print(ans)

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

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

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

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

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

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

n = sorted(l)[1] + sorted(l)[0]

print(sorted(l)[2]*10 + n)

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

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

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

ans = max(a) * 10
del a[a.index(max(a))]
ans += max(a)
print(ans + min(a))

Solution (Python):
import itertools
t = input().split()
ans = 0
for i in itertools.permutations(t, 3):
    ans = max(ans, int(i[0]+i[1])+int(i[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):
a,b,c = map(int,input().split())
x = max([a,b,c])
ans = x*9 + sum([a,b,c]) 
print(ans)

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

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

Solution (Python):
l=list(input().split())
l.sort(reverse=True)

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

Solution (Python):
x = list(map(int,input().split()))
y = sorted(x,reverse=True)

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

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

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

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

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

Solution (Python):
args = input().split()
args.sort(reverse=True)

num1 = int(''.join(args[0:2]))
num2 = int(''.join(args[2:3]))

print(num1+num2)

Solution (Python):
args = input().split()
args.sort(reverse=True)

num1 = int(''.join(args[0:2]))
num2 = int(''.join(args[2:3]))

print(num1+num2)

Solution (Python):

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

Solution (Python):


S=sorted(list(map(str,input().split())),reverse=True)

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

Solution (Python):


S=sorted(list(map(int,input().split())))

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

Solution (Python):
import sys
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()

a, b, c = na()

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

Solution (Python):



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

temp_list=[]
temp_list += [int(A) + int(B+C)]
temp_list += [int(A) + int(C+B)]
temp_list += [int(B) + int(A+C)]
temp_list += [int(B) + int(C+A)]
temp_list += [int(C) + int(A+B)]
temp_list += [int(C) + int(B+A)]

print(max(temp_list))

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

Solution (Python):
a = [int(x) for x in input().split()]
a.sort()
ans = a[-1]*10 + sum(a[:2])
print(ans)

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

Solution (Python):
class Solution:
    def solve(self, A: int, B: int, C: int) -> str:

        s = sorted([A, B, C])

        return s[0] + s[1] + 10*s[2]


if __name__ == '__main__':

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

    
    solution = Solution()
    print(solution.solve(A, B, C))

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

Solution (Python):

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

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

print(max(A, B, C) * 10 + (A + B + C - max(A, B, C) - min(A, B, C)) + min(A, B, C))

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):
A = list(map(int, input().split()))
m = max(A)
A.remove(m)
print(m * 10 + A[0] + A[1])

Solution (Python):
a = sorted(list(input()), reverse=True)
print(int(''.join(a[:2])) + int(a[2]))

Solution (Python):
list = list(input().split())
list.sort(reverse=True)

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

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

a.sort()

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

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

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

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

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

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

Solution (Python):
A,B,C = map(int,raw_input().split())
max_num=A
if max_num < B:
    max_num = B
if max_num < C:
    max_num= C
print max_num*9+(A+B+C)

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

print max_num * 9 + (a + b + 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())
ans=a+b+c+max(a,b,c)*9
print(ans)

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):
abc = sorted(map(int, input().split()))
print(abc[0] + int(str(abc[2])+str(abc[1])))

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

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

print(9*max(a)+sum(a))

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

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

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

Solution (Python):
a = tuple(map(int,input().split()))
M = max(a)
m = min(a)
n = sorted(a)[-2]

print(10*M + n + m)

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 = map(int, input().split())
ans = 0
print(max(10 * a + b + c, 10 * b + a + c, 10 * c + a + b))

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

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

Solution (Python):
def calc_max_fomula_by_list(numbers: list) -> int:
    sorted_numbers = numbers
    sorted_numbers.sort(reverse=True)
    return sorted_numbers[0] * 10 + sorted_numbers[1] + sorted_numbers[2]
    

def main():
    inputs = list( map(lambda x:int(x), input().split(' ')) )
    print(calc_max_fomula_by_list(inputs))


if __name__ == '__main__':
    main()

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

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

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

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

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

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

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]
a,b,t = map(int,input().split(' '))

S = a+b+t
M = max(a,b,t)
print(M*10+(S-M))

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

Solution (Python):
arr = list(map(str, input().split()))
arr.sort()
arr.reverse()

x = arr[0] + arr[1]
x = int(x)
print(x+int(arr[2]))

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

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

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

Solution (Python):
v = list(map(int, input().split()))
v.sort()
d = v.pop()
print(10 * d + sum(v))

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

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()))
l.sort()
print(l[2]*10+l[0]+l[1])

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

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

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

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

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

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

Solution (Python):




def main():
    ABC = input().split()
    ABC.sort(reverse=True)
    print(int(ABC[0] + ABC[1]) + int(ABC[2]))


if __name__ == "__main__":
    main()

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

Solution (Python):
A, B, C = list(map(int, input().split()))
h = [A, B, C]
maxvalue = -1
for i in h:
    if i > maxvalue:
        maxvalue = i
minvalue = 10
for i in h:
    if i < minvalue:
        minvalue = i
print(maxvalue*10+A+B+C-maxvalue-minvalue+minvalue)

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):
a,b,c = sorted(map(int,input().split()))
print(a+b+10*c)

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

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

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

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

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

print(int(str(a[0])+str(a[1]))+a[-1])

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

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

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

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


if __name__ == '__main__':
    main()

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

Solution (Python):
num = list(map(int, input().split()))
num_s = sorted(num, reverse=True)

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

print(ans)

Solution (Python):
A,B,C=map(int,input().split())
l=[A,B,C]
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):
card = list(map(int, input().split()))
A = max(card)
A_index = card.index(max(card))
ans = 0
for i in range(3):
    ans+=card[i]
    if i == A_index:
        ans-=card[i]
print(ans+10*A)

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

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

Solution (Python):
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)
 
a,b,c = sorted(map(int,readline().split()))
print (10 * c  + b + a)

Solution (Python):
l=list(map(str, input().split()))
list.sort(l, reverse=True)

s=int(l[0]+l[1])
print(s+int(l[2]))

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

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

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

max_num = nums.pop(nums.index(max(nums)))

output = max_num * 10 + sum(nums)

print(output)

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

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

Solution (Python):
import itertools
S = input().split()
m = 0
for n in itertools.permutations(range(3)):
    m = max(m, eval(S[n[0]]+"+"+S[n[1]]+S[n[2]]))
print(m)

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

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

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

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

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

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

num.sort(reverse=True)
X = num[0] + num[1]

print(int(X) + int(num[2]))

Solution (Python):
L = sorted(input().split())[::-1]
A = L[0]+L[1]
B = L[-1]

print(int(A) + int(B))

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

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

Solution (Python):
"""
author : halo2halo
date : 22, Jan, 2020
"""

import sys



read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

a, b, c = map(int, readline().split())
print(max(10*a+b+c,a+10*b+c,a+b+10*c))

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

d = sorted([a,b,c])

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

Solution (Python):
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input(): return sys.stdin.readline().rstrip()

def main():
    A,B,C=map(int,input().split())
    M=max(A,B,C)
    ans=M*10
    f=False
    for x in A,B,C:
        if x!=M or f:
            ans+=x
        else:
            f=True
    print(ans)

if __name__ == '__main__':
    main()

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

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

Solution (Python):
from itertools import permutations


def solve():
    A, B, C = map(str, input().split())
    ans = 0
    for a, b, c in permutations(A + B + C, 3):
        ans = max(ans, int(a + b) + int(c))
    print(ans)


if __name__ == '__main__':
    solve()

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

largest = max(A, B, C)
smallest = min(A, B, C)
mid = A + B + C - largest - smallest
ans = 10 * largest + mid + smallest

print(ans)

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

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

Solution (Python):
from __future__ import print_function

import sys
input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return

















































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


if __name__ == '__main__':
    main()

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

Solution (Python):
import math
import queue
import bisect
import heapq
import time
import itertools

mod = int(1e9+7)

def swap(a,b):
    return (b,a)

def my_round(a,dig=0):
    p = 10 ** dig
    return (a * p * 2 + 1) // 2 / p

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

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

def divisors(a): 
    divisors = []
    for i in range(1,int(a**0.5)+1):
        if a%i==0:
            divisors.append(i)
            if i!=a//i:
                divisors.append(a//i)
    return divisors

def is_prime(a): 
    if a<2:
        return False
    elif a==2:
        return True
    elif a%2==0:
        return False
    sqrt_num = int(a**0.5)
    for i in range(3,sqrt_num+1,2):
        if a%i==0:
            return False
    return True

def prime_num(a): 
    pn = [2]
    for i in range(3,int(a**0.5),2):
        prime = True
        for j in pn:
            if i%j==0:
                prime = False
                break
        if prime:
            pn.append(i)
    return pn

def prime_fact(a): 
    sqrt = math.sqrt(a)
    res = []
    i = 2
    if is_prime(a):
        res.append(a)
    else:
        while a!=1:
            while a%i==0:
                res.append(i)
                a //= i
            i += 1
    return res

def main():
    x = [y for y in map(int,input().split())]
    x.sort()
    ans = x[2] * 10 + x[1] + x[0]
    print(ans)
    return

if __name__=='__main__':
    main()

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

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

Solution (Python):
def main():
    lis = list(input().split())
    anolis = sorted(lis, reverse=True)
    anolis.insert(2,'+')
    print(eval(''.join(anolis)))
 
main()

Solution (Python):
def main():
    from sys import stdin
    r = stdin.readline()[:-1]
    
    
    

    a, b, c = map(int, r.split())
    print(max(a*10+b+c, a+b*10+c, a+b+c*10))

if __name__ == '__main__':
    main()

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

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[-1]*10+a[1]+a[0])

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

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

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

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

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

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

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, b, c=sorted(map(int, input().split()))
print(c*10+b+a)

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

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

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

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())
L = [A, B, C]
L.sort()

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

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

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

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

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

Solution (Python):
def main():
    lis = list(input().split())
    anolis = sorted(lis, reverse=True)
    anolis.insert(2,'+')
    print(eval(''.join(anolis)))

main()

Solution (Python):
nSorted = sorted(list(map(int,input().split())),reverse=True)

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

Solution (Python):
import sys

a = sys.stdin.readline().split()

def main():
    a.sort(reverse=True)
    a.insert(2, '+')
    return eval(''.join(a))

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

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

print(max(
    int(A+B) + int(C),
    int(B+A) + int(C),
    int(B+C) + int(A),
    int(C+B) + int(A),
    int(A+C) + int(B),
    int(C+A) + int(B)
))

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

t = max(a, b, c)

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

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

Solution (Python):
a, b, c = map(lambda x: int(x), input().split())
lis = [a, b, c]
lis.sort()
lis.reverse()

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

Solution (Python):
import itertools
lst = list(map(str,input().split()))
lst1 = list(itertools.permutations(lst))

ans_array = []
for i in range(len(lst1)):
    num1 = int(lst1[i][0]+lst1[i][1]) + int(lst1[i][2])
    num2 = int(lst1[i][0]) + int(lst1[i][1]+lst1[i][2])
    ans_array.append(num1)
    ans_array.append(num2)
print(max(ans_array))

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

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

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

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

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

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

Solution (Python):
Abc = list(map(int, input().split()))
ans = 0
for i in range(len(Abc)):
    ans = max( Abc[i]+Abc[(i+1)%3]+Abc[(i+2)%3]*10, ans )
print(ans)

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

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

Solution (Python):
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7



A = list(map(int, sys.stdin.buffer.readline().split()))
A.sort(reverse=True)
ans = int(str(A[0]) + str(A[1])) + A[2]
print(ans)

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

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

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

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

Solution (Python):


panels = sorted([int(i) for i in input().rstrip().split(" ")])
panels.reverse()

ans = panels[0] * 10 + (sum(panels) - panels[0])
print(ans)

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

Solution (Python):
n=[int(i) for i in input().split()]
m=max(n)
n.remove(m)
print(m*10+n[0]+n[1])

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

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

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

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

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

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

t_re=sorted(t, reverse=True)

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

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

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

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

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b,c=INTM()
    print(a+b+c+9*max(a,b,c))
if __name__ == '__main__':
    do()