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

num_list.sort()

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

print(ans)

Solution (Python):


from collections import deque
import itertools as it
import sys
import math

sys.setrecursionlimit(1000000)

ls = map(int, raw_input().split())

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

Solution (Python):
import math
array = list(map(int, input().strip().split()))
array.sort()
ans=array[2]*10+array[1]+array[0]


    
print(ans)

Solution (Python):



input = raw_input().split(" ")
numberlist = [int(i) for i in input]
numberlist.sort(reverse=True)

result = numberlist[0] * 10 + numberlist[1] + numberlist[2]
print result

Solution (Python):
import statistics
import math
Num=[int(i) for i in input().split()]
median=statistics.median(Num)
print(max(Num)*10+median+min(Num))

Solution (Python):
A = [0, 0, 0]
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())

ans= 0

for i in range(6):
  ans = max(a*10+b+c,max(b*10+c+a,c*10+a+b))
print(ans)

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

Solution (Python):

def main():
    nums = list(map(int, input().split()))
    a = max(nums)
    nums.remove(a)
    print(a*10+nums[0]+nums[1])

if __name__ == '__main__':
    main()

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

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

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

for i in range(len(lists)):
    lists[i]=int(lists[i])

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

Solution (Python):

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

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

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

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

main()

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

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

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

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

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

Solution (Python):
import sys
import socket

hostname = socket.gethostname()

if hostname == 'F551C':
    sys.stdin = open('a1.in')


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


def read_str_list():
    return input().split()


def read_int():
    return int(input())


def read_str():
    return input()


def main():
    a, b, c = read_int_list()
    x = 10 * a + b + c
    y = 10 * b + a + c
    z = 10 * c + a + b
    res = max([x, y, z])
    print(res)


main()

Solution (Python):
l = [int(i) for i in input().split()]
if(l.index(max(l))==0):
  print(l[0]*10+l[1]+l[2])
elif(l.index(max(l))==1):
  print(l[1]*10+l[0]+l[2])
else:
  print(l[2]*10+l[1]+l[0])

Solution (Python):


nums = input().split(" ")
a = int(nums[0])
b = int(nums[1])
c = int(nums[2])
num_list = [a, b, c]

max_num = max(num_list)
min_num = min(num_list)

if max_num == a:
	max_index = 0
elif max_num == b:
	max_index = 1
else:
	max_index = 2

if min_num == a and max_index != 0:
	min_index = 0
elif min_num == b and max_index != 1:
	min_index = 1
else:
	min_index = 2

index_list = [0, 1, 2]
index_list[max_index] = "abc"
index_list[min_index] = "abc"
if index_list[0] == 0:
	middle_index = 0
elif index_list[1] == 1:
	middle_index = 1
else:
	middle_index = 2

answer = int( str(num_list[max_index]) + str(num_list[middle_index]) ) + num_list[min_index]

print(answer)

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

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

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

ans = 0
for k1, v1 in enumerate(input_data):
    for k2, v2 in enumerate(input_data):
        for k3, v3 in enumerate(input_data):
            if k1 == k2 or k2 == k3 or k3 == k1:
                continue
            kou1 = int(str(v1) + str(v2))
            kou2 = v3
            if ans < kou1 + kou2:
                ans = kou1 + v3
print(ans)

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

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

Solution (Python):
a,b,c = map(int,input().split())
def max(a,b,c):
 if a >= b >= c or a >= c >= b: return 10*a+b+c
 elif b >= c >= a or b >= a >= c: return 10*b+c+a
 elif c >= a >= b or c >= b >= a: return 10*c+a+b
print(max(a,b,c))

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

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

    return a

numbers = bSort(input_int)

max = numbers[-1]
mid = numbers[1]
min = numbers[0]

A = str(max) + str(mid)
B = min

print(int(A)+B)

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

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

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

Solution (Python):
def main():
	A, B, C = [int(_) for _ in input().split()]

	l_max=max(A,B,C)
	l_min=min(A,B,C)
	l_mid=(A+B+C)-(l_max+l_min)

	ans=10*l_max+l_mid+l_min
	print(ans)
    
main()

Solution (Python):
from sys import stdin
xs = [int(x) for x in stdin.readline().rstrip().split()]
a = xs[0] * 10 + xs[1] + xs[2]
b = xs[0] + xs[1] * 10 + xs[2]
c = xs[0] + xs[1] + xs[2] * 10
print(max(max(a, b),c))

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

a.sort(reverse=True)


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

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

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

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

x.sort()

m= x[2]*10+ x[1]+x[0]

print(m)

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

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

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

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

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):
l=list(map(int,input().split()))
print(max(l)*10+sum(l)-max(l))

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

sortedList = sorted(List, reverse=True)
print(int(sortedList[0]+sortedList[1]) + int(sortedList[2]))

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

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

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

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

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

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

A.sort()
M = 10 * int(A[-1]) + int(A[0]) + int(A[1])
print(M)

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

m=max(a,b,c)

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

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

Solution (Python):
def return_biggest_sum(numbers):
    """入力 [int, int, int]
    """
    numbers.sort()
    numbers.reverse() 
    return int(str(numbers[0])+str(numbers[1])) + numbers[2]

line = input()
numbers_list = list(map(int, line.split()))
print(return_biggest_sum(numbers_list))

Solution (Python):
nums = [int(i)for i in input().split()]
nums = sorted(nums,reverse=True)
strnum = str(nums[0]) + str(nums[1])
x = int(strnum)
y = nums[2]
print(x+y)

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


new_data=sorted(data)

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

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

Solution (Python):
A, B, C = tuple(int(i) for i in input().split())

l = [A, B, C]
m = max(l)
l.remove(m)
print(m*10 + l[0] + l[1])

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

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

Solution (Python):
abc = input().split()
a = abc[0]
b = abc[1]
c = abc[2]

d = eval((a + b) + '+' + c)
e = eval((b + a) + '+' + c)
f = eval((a + c) + '+' + b)
g = eval((c + a) + '+' + b)
h = eval((b + c) + '+' + a)
i = eval((c + b) + '+' + a)

h = [d, e, f, g, h, i]

print(max(h))

Solution (Python):
string = input().split()
num = [int(x) for x in string]
max_idx = num.index(max(num))

res = 0
for x in range(len(num)):
    if x == max_idx:
        res += num[x]*10
    else:
        res += num[x]

print(res)

Solution (Python):



line = input().split( )
line = [int(s) for s in line]
a = []
a.append(line[0]* 10 + line[1] + line[2])
a.append(line[1]* 10 + line[0] + line[2])
a.append(line[2]* 10 + line[0] + line[1])
print(max(a))

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

Solution (Python):
a = list(map(int,input().split()))
temp = max(a)
a.pop(a.index(max(a)))
print(int(str(temp)+str(max(a)))+min(a))

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

l = sorted(l)


f = 10 * int(l[2]) +  int(l[1]) + int(l[0])


print(f)

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

data = [A,B,C]
                 
data.sort()
                 
print(str(data[2]*10+data[1]+data[0]))

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

Solution (Python):
panels = input().split()
panels = [int(panel) for panel in panels]
panels = sorted(panels,reverse=True)

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

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

Solution (Python):


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

print(max(eval(A + '+' + B + C), eval(A + B + '+' + C), eval(B + '+' + C + A),
        eval(A + '+' + C + B), eval(B + A + '+' + C), eval(B + '+' + A + C)))

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

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

x = str(z[0]) + str(z[1])
x = int(x)
y = int(z[2])

print(x + y)

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

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

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

e = 0

e = a*10+b+c

if e < b*10+a+c:
    e = b*10+a+c
    if e < c*10+a+b:
        e = c*10+a+b

if e < c*10+a+b:
    e= c*10+a+b
    if e < b*10+a+c:
        e = b*10+a+c

print(e)

Solution (Python):
A=list(map(int, input().split()))
for i in range(3):
	for j in range(2):
		if A[j]<A[j+1]:
			temp_A=A[j]
			A[j]=A[j+1]
			A[j+1]=temp_A
print(A[0]*10+A[1]+A[2])

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

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

p = [A, B, C]

p.sort()

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

Solution (Python):
value = []
for part in input().split():
    value.append(int(part))

value.sort()
value.reverse()

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

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

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

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

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

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

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

if A <= B and B <= C:
    a = A
    b = B
    c = C
elif A <= B and C <= A:
    a = C
    b = A
    c = B
elif A <= C and C <= B:
    a = A
    b = C
    c = B
elif B <= A and A <= C:
    a = B
    b = A
    c = C
elif B <= C and C <= A:
    a = B
    b = C
    c = A
else:
    a = C
    b = B
    c = A

max_num = int(str(c) + str(b)) + a

print(max_num)

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

A.sort()

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

Solution (Python):




"""








"""
def get_input():
    return [i for i in input().split(" ")]

def make_it(num_list):
    """
    >>> make_it(['1','5','2'])
    """
    res = list(sorted(num_list, reverse=True))
    st = res[0] + res[1]
    return int(st) + int(res[2])

if __name__ == '__main__':
    print(make_it(get_input()))

Solution (Python):


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

b = sorted(a,reverse=True)

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

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

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


if __name__ == '__main__':
    main()

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

ans = (A*10+B) + C

tmp = (A*10+C) + B
if tmp > ans:
    ans = tmp

tmp = (B*10+A) + C
if tmp > ans:
    ans = tmp

tmp = (B*10+C) + A
if tmp > ans:
    ans = tmp

tmp = (C*10+B) + A
if tmp > ans:
    ans = tmp

tmp = (C*10+A) + B
if tmp > ans:
    ans = tmp

print(ans)

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

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

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

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

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

tmp_max = 10*A + B + C 

if tmp_max < 10*B + C +A:
    tmp_max = 10*B + C +A

if tmp_max < 10*C + A +B:
    tmp_max = 10*C + A +B


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

Solution (Python):

A, B, C = (int(i) for i in 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):
data = input().split()
a = max(data)
data.remove(a)
b = max(data)
data.remove(b)
c = int(max(data))
d = str(a)+str(b)
num = int(d)
print(num+c)

Solution (Python):


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

Solution (Python):



def main():
    A, B, C = raw_input().split()
    a = int(A + B) + int(C)
    b = int(A + C) + int(B)
    c = int(B + A) + int(C)
    d = int(B + C) + int(A)
    e = int(C + B) + int(A)
    f = int(C + A) + int(B)
    print(max(a, b, c, d, e, f))


if __name__ == "__main__":
    main()

Solution (Python):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(input())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())

abc = inpl()
abc.sort()

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

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

Solution (Python):

A, B, C = [int(i) for i in input().split(' ')]

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

Solution (Python):

"""
Created on Sun Sep 23 21:00:48 2018

@author: masato
"""

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

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

Solution (Python):
A=list(map(int,input().split()))
x=0
for i in A:
    x+=i
x+=max(A)*9
print(x)

Solution (Python):


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

arr = [a, b, c]
arr.sort()

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

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

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

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

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

Solution (Python):
A,B,C=list(input().split())
X=[A,B]
D=int("".join(X))+int(C)
X=[B,A]
E=int("".join(X))+int(C)
X=[A,C]
F=int("".join(X))+int(B)
X=[C,A]
G=int("".join(X))+int(B)
X=[B,C]
H=int("".join(X))+int(A)
X=[C,B]
I=int("".join(X))+int(A)

print(max([D,E,F,G,H,I]))

Solution (Python):

ABC =  list(int(i) for i in input().split())

a1 = max(ABC)

ABC.remove(a1)

a2 = max(ABC)
a3 = min(ABC)

ans = a1*10 + a2 + a3
print(ans)

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

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

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

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

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

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

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

Solution (Python):
_in = input()

nums = [int(n) for n in _in.split(" ")]
nums = sorted(nums, reverse=True)

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

Solution (Python):
A,B,C=[int(i) for i in input().split()]
list=[]
list.append(A)
list.append(B)
list.append(C)
max=max(list)
list.remove(max)

print(10*max+sum(list))

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

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

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

Solution (Python):
l = [int(_) for _ in input().split()]
l.sort(reverse=True)

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

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

print(a + b + c*10)

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

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

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

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

Solution (Python):



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


if __name__ == '__main__':
    main()

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

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

Solution (Python):
import sys
import numpy as np

a, b, c =list(map(int, sys.stdin.readline().strip().split(" ")))

i = np.argmax([a, b, c])
l = [a, b, c]
m = l[i]
l.pop(i)
print(m*10 + l[0] + l[1])

Solution (Python):



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

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())
pat1 = a + 10 * b + c
pat2 = 10 * a + b + c
pat3 = a + b + 10 * c
print(max(pat1, pat2, pat3))

Solution (Python):
from itertools import permutations

maxi = -1

for a, b, c in permutations(input().split()):
    abPc = int(a + b) + int(c)
    maxi = max(maxi, abPc)

print(maxi)

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

result=L[0]*10+L[1]+L[2]

print(result)

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

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

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

print(max(a)*10-max(a)+sum(a))

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

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

Solution (Python):

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

ls =[A,B,C]

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

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

list = []
list.append(a)
list.append(b)
list.append(c)

mx = max(list)

ans = mx * 10

for i in range(3):
  ans += list[i]

ans = ans - mx

print(ans)

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

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

ab=a*10+b
ba=b*10+a

bc=b*10+c
cb=c*1-+b

ca=c*10+a
ac=a*10+c

ans=max(ab+c,ba+c,bc+a,cb+a,ca+b,ac+b)

print ans

Solution (Python):




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



d = max(a,b,c)
if a==d:
    a*=10
elif b==d:
    b*=10
elif c==d:
    c*=10
print("{}".format(a+b+c))

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

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

Solution (Python):
import itertools
A,B,C=map(int,input().split())
L=[str(A),str(B),str(C),"+"]
S=list(itertools.permutations(L,4))
ans=0
for seq in S:
    if seq[0]=="+" or seq[3]=="+":
        continue
    eq="".join(seq)
    tmp=eval(eq)
    if ans<tmp:
        ans=tmp
print(ans)

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

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

a = int(A)
b = int(B)
c = int(C)

num = []
num.append(a)
num.append(b)
num.append(c)
num.sort()
print(num[2]*10+num[1]+num[0])

Solution (Python):
input_list = [int(elem) for elem in input().split(' ')]
input_list.sort()
answer = input_list[2] * 10 + input_list[1] + input_list[0]
print(answer)

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

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

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

Max=max(A)
Min=min(A)
A.remove(Max)
A.remove(Min)

print(10*Max+Min+A[0])

Solution (Python):

num = list(int(i) for i in input().split())

num.sort(reverse=True)

max = int(str(num[0])+str(num[1]))+num[2]

print(max)

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

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

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

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

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

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

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

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

panel.sort()
panel.reverse()

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

Solution (Python):
abc = list(map(int, input().split()))
maxim = max(abc)
abc.remove(maxim)
second = max(abc)
abc.remove(second)
third = max(abc)

print(maxim*10+second+third)

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

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

arr.sort(reverse=True)

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

Solution (Python):



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

    maxnum = max(li)
    li.remove(max(li))

    li.append(maxnum * 10)
    print(sum(li))


if __name__ == '__main__':
    main()

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

num = []
num.append(int(A))
num.append(int(B))
num.append(int(C))

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

Solution (Python):
def getValue(A, B, C, List):
  D=A+B
  Sum=int(D)+int(C)
  List.append(Sum)
  return List
  
A, B, C=input().split()

List=[]
List=getValue(A, B, C, List)
List=getValue(A, C, B, List)
List=getValue(B, A, C, List)
List=getValue(B, C, A, List)
List=getValue(C, B, A, List)
List=getValue(C, A, B, List)

print(max(List))

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

Solution (Python):


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

sortedNum = sorted(num)

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

print(ans)

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

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

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

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

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

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

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

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

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(B+C)+int(A), int(C+A)+int(B),int(C+B)+int(A)))

Solution (Python):


import sys

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

a.sort()
a.reverse()

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

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

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()))
d = max(a)
a.remove(d)
print(d*10+sum(a))

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

ns.sort()
ns.reverse()

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

print(sum)

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

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

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

Solution (Python):


nums = [int(s) for s in input().split(" ")]
nums.sort(reverse=True)
print(nums[0] * 10 + nums[1] + nums[2])

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(10000)


def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, A):
    ans = 0
    return ans


def main():
    A, B, C = read_int_n()
    ans = max(A, B, C) * 10 + A + B + C - max(A, B, C)

    print(ans)


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
if __name__ == '__main__':
    A, B, C = list(map(int, input().split()))
    if A >= B and A >= C:
        print(10*A+B+C)
    elif B >= A and B>=C:
        print(B*10+A+C)
    else:
        print(C*10+A+B)

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

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

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

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

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

Solution (Python):
a,b,c=  map(int,input().split())
temp= [a,b,c]
temp.sort()
temp1=int(str(temp[-1])+str(temp[-2]))
print(temp1+temp[0])