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

t = sorted([A, B, C])
print(t[0] + t[1] + t[2] * 10)

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

a.sort(reverse=True)

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

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

Solution (Python):
n = list(map(int, input().split()))
n.sort()
print(n[0] + n[1]+n[2]*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):
n_l = list(map(str, input().split()))

n_l.sort(reverse=True)

print(int(n_l[0] + n_l[1]) + int(n_l[-1]))

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

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

Solution (Python):

url = "https://atcoder.jp//contests/abc110/tasks/abc110_a"

def main():
    t = list(map(int, input().split()))
    t.sort(reverse=True)

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

if __name__ == '__main__':
    main()

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

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

Solution (Python):


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


if __name__ == "__main__":
    main()

Solution (Python):
lis = []
li = input().split()

li.sort()

lis.append(li[2] + li[1])
lis.append(li[0])

print(int(lis[0]) + int(lis[1]))

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

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

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

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

Solution (Python):
def mapt(fn, *args):
    return tuple(map(fn, *args))


def Input():
    return mapt(int, input().split(" "))


def main():
    data = sorted(Input(), reverse=True)
    print(int(str(data[0])+str(data[1])) + data[2])


main()

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

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

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

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

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

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

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

Solution (Python):

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

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

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

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

A.sort()
A=A[::-1]

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

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

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

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

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

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

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

Solution (Python):
n = map(int, input().split())
list_num = list(n)
list_num.sort()
list_str = []
for i in list_num:
    i = str(i)
    list_str.append(i)

max_str = list_str[-1] + list_str[1]
max_int = int(max_str)
print(max_int + int(list_str[0]))

Solution (Python):
l=input().split()
ld = sorted(l, reverse=True)

a=ld[0]+ld[1]
b=ld[2]
m=int(a)
n=int(b)
print(m+n)

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

from math import floor, ceil, sqrt, factorial, log, gcd
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict
from heapq import heappop, heappush, heappushpop, heapify
import copy
import numpy as np
import sys
INF = float('inf')
mod = 10**9+7
sys.setrecursionlimit(10 ** 6)


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





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




def I(): return int(sys.stdin.buffer.readline())





def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()




def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')







def IR(n): return [I() for i in range(n)]







def LIR(n): return [LI() for i in range(n)]







def SR(n): return [S() for i in range(n)]







def LSR(n): return [LS() for i in range(n)]







def SRL(n): return [list(S()) for i in range(n)]


def main():
    n = list(LI())
    m = max(n)
    n.remove(m)
    print(m*10+sum(n))


if __name__ == "__main__":
    main()

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

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

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

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

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

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


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


if __name__ == '__main__':
    main()

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

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

Solution (Python):
ABC = input().split()
m = max(ABC)
ABC.remove(m)

print(eval(m + ABC[0] + '+' + ABC[1]))

Solution (Python):

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

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

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

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

Solution (Python):
x = list(map(int, input().split()))
a = max(x)
b = min(x)
x.remove(a)
x.remove(b)
c = x[0]
a = str(a)
b = str(b)
ab = int(a+b)
print(ab+c)

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

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

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

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

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

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

Solution (Python):
a=input().split()
a.sort(reverse=True)
if len(set(a))==1:
  print(12*int(a[0]))
else:
  ans=int(a[0]+a[1])+int(a[2])
  print(ans)

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

if A >= B and A >= C:
  print(int(A*10+B+C))
elif B >= A and B >= C:
  print(int(B*10+A+C))
else:
  print(int(C*10+A+B))

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

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

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

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=input().split()
a=int(a)
b=int(b)
c=int(c)
ls=[a,b,c]
ls.sort()
print(ls[2]*10+ls[1]+ls[0])

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

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

print(10*c+b+a)

Solution (Python):
ls = list(map(int,input().split()))
ls.sort(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):
lst = list(map(int, input().split()))
lst.sort()
lst.reverse()
maximum = int(str(lst[0]) + str(lst[1])) + lst[2]
print(maximum)

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(a, b, c) * 9 + a + b + c)

Solution (Python):
a, b, c = map(int, input().split())
M = max(a, b, c)
r = a+b+c-M

print(10*M + r)

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

if a == max(a,b,c):
    ans = int(a+b) + int(c)
elif b == max(a,b,c):
    ans = int(b+a) + int(c)
else:
    ans = int(c+a) + int(b)
print(ans)

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

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

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

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

a.sort()

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

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

Solution (Python):
abc=sorted(list(map(int,input().split())),reverse=True)
a=[1]*10
for i in range(10**7+5*10**6):
    a.append(a)
print(sum(abc)+abc[0]*9)

Solution (Python):
abc=sorted(list(map(int,input().split())),reverse=True)
a=[1]*10
for i in range(10**7):
    a.append(a)
print(sum(abc)+abc[0]*9)

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

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

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

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

x = a[0]
y = a[2]+a[1]

print(int(x)+int(y))

Solution (Python):
import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush,heapify
from math import ceil, floor, sqrt
from copy import deepcopy

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

if __name__ == "__main__":
    main()

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

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

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

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

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 = list(map(int, input().split()))
a = sorted(a, reverse=True)

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

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


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

    return


if __name__ == '__main__':
    main()

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

print(a[-1]*10+sum(a[:-1]))

Solution (Python):









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

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

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

Solution (Python):
import sys


stdin = sys.stdin
def ns(): return stdin.readline().rstrip()
def ni(): return int(stdin.readline().rstrip())
def nm(): return map(int, stdin.readline().split())
def nl(): return list(map(int, stdin.readline().split()))


def main():
    A = sorted(nl())
    print(eval(str(A[2]) + str(A[1]) + '+' + str(A[0])))


if __name__ == '__main__':
    main()

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

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

Solution (Python):
l = list(map(int, input().split()))
i = l.index(max(l))
print(l.pop(i) * 10 + sum(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())
print(max(A*10+B+C,B*10+A+C,C*10+B+A))

Solution (Python):

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


if __name__ == "__main__":
    main()

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().strip().split(" "))
k=max(a,b,c)
print(9*k+a+b+c)

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

Solution (Python):
A,B,C = map(int,input().split())
ans = 0
if(A>=B and A>=C):
    ans = max(A*10+B+C,ans)
if(B>=A and B>=C):
    ans = max(B*10+A+C,ans)
else:
    ans = max(C*10+A+B,ans)
print(str(ans))

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



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

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

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

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

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

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

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

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

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

Solution (Python):
import sys
import math


sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))

abc = inl()

ans = sum(abc)
max_n = max(abc)

print(ans - max_n + max_n*10)

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

N = sorted(N, 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):
Num = sorted(input().split(),reverse=True)
print(int(Num[0]+Num[1])+int(Num[2]))

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

Solution (Python):
n=sorted(input().split());print(int(n.pop()+n.pop())+int(n.pop()))

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

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

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

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

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

print(max(x, y, z))

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

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

Solution (Python):
n= [int(s) for s in input().split()]
n.sort()
max_value = n[2] * 10 + n[1] + n[0]

print(max_value)

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

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

Solution (Python):
if __name__ == '__main__':
	A = list(map(int,input().split()))
	B = sorted(A,reverse=True)

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

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=input().split()
print(max(int(A+B)+int(C),int(A+C)+int(B),int(B+A)+int(C),int(C+A)+int(B),int(B+C)+int(A),int(C+B)+int(A)))

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
















































def calculation(lines):
    
    a, b, c = list(map(int, lines[0].split()))
    result = max(a, b, c) * 9 + a + b + c
    return [result]



def get_input_lines(lines_count):
    lines = list()
    for _ in range(lines_count):
        lines.append(input())
    return lines



def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['1 5 2']
        lines_export = [53]
    if pattern == 2:
        lines_input = ['9 9 9']
        lines_export = [108]
    if pattern == 3:
        lines_input = ['6 6 7']
        lines_export = [82]
    return lines_input, lines_export



def get_mode():
    import sys
    args = sys.argv
    if len(args) == 1:
        mode = 0
    else:
        mode = int(args[1])
    return mode



def main():
    import time
    started = time.time()
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines(1)
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    
    
    
    
    
    
    
    
    
    
    



if __name__ == '__main__':
    main()

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

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    A, B, C = input().split()

    ans = max(int(A + B) + int(C), int(B + C) + int(A), int(C + A) + int(B))

    print(ans)


if __name__ == "__main__":
    main()

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

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

Solution (Python):


import math

import itertools
from collections import deque
from collections import Counter

from fractions  import gcd

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

Solution (Python):
def resolve():
    import itertools
    A = [i for i in input().split()] + ["+"]
    maxA = 0
    for a in itertools.permutations(A):
        if a[0] != "+" and a[-1] != "+":
            maxA = max(maxA, eval("".join(a)))
    print(maxA)


resolve()

Solution (Python):

import sys
input = sys.stdin.readline  

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

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

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):
l = sorted(map(int,input().split()))

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

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

num_list = sorted(num_list)

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

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

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):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

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

print(10*C + A + B)

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

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

A = a[2]
B = a[1]
C = a[0]


ans = max(A+int(str(B) + str(C)),int(str(A) + str(B))+C)
print(ans)

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

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

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

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

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

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

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

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

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

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

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

main()

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

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

Solution (Python):

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

Solution (Python):
A,B,C=map(int,input().split())
a=(A,B,C)
b=sorted(a)
c=(str(b[2]),str(b[1]))
d=''.join(c)
e=int(d)
print(e+b[0])

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

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

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

lists = [a,b,c]

maxi = max(lists)
mini = min(lists)

print(maxi*10 + a + b + c -maxi)

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

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

arr.sort()

A = int(str(arr[2])+str(arr[1]))

B = int(arr[0])

print( A + B )

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

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

Solution (Python):


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

abc.sort()

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

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

Solution (Python):
import sys
array_no = list(map(int,input().split()))
for I in array_no:
    if not (1 <= I <= 9): sys.exit()

max_first = array_no.pop(array_no.index(max(array_no)))
max_second = array_no.pop(array_no.index(max(array_no)))
print(int(str(max_first)+str(max_second)) + array_no[0])

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

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

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

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

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

Solution (Python):
import sys

rl = lambda: list(map(int, sys.stdin.buffer.readline().split()))

a = sorted(rl(), reverse=True)
print(a[0]*10 + a[1] + a[2])

Solution (Python):
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.buffer.readline().split())
rl = lambda: list(map(int, sys.stdin.buffer.readline().split()))
inf = float('inf')
mod = 10**9 + 7

a = sorted(rl(), reverse=True)
print(a[0]*10 + a[1] + a[2])

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

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

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

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

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

res = 0
res = max(res, a * 10 + b + c)
res = max(res, b * 10 + a + c)
res = max(res, c * 10 + b + a)

print(res)

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

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

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

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

Solution (Python):
import itertools

aa = tuple(map(int, input().split()))
ma = 0
for a in itertools.permutations(aa, 3):
    ma = max(ma, a[0] * 10 + a[1] + a[2])
print(ma)

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
li = LI()
li.sort(reverse=True)
print(int(str(li[0]) + str(li[1])) + li[2])

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


if '__main__' == __name__:
    resolve()

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

f = max(a, b, c)
if f == a:
    print(a*10 + int(str(b+c)))
elif f == b:
    print(b*10 + int(str(a+c)))
else:
    print(c*10 + int(str(b+a)))

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

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

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

A.sort()

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

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    ABC = LI()

    ABC.sort()

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

if __name__ == '__main__':
    resolve()

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

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

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

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

if x>y and x>z:
  print(x)
elif y > z:
  print(y)
else:
  print(z)

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

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

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

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

Solution (Python):
l = input().split()
for i in range(len(l)):
    l[i] = int(l[i])
    
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):
l=list(map(int,input().split()))
l.sort()
print(l[-1]*10+l[-2]+l[-3])

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

num.sort()

e = (num[2]*10) + num[1] +num[0] 

print(e)

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

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

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

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