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):
import numpy as np
ABC  =list(map(int, input().split()))
orders = [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0],  [2, 0, 1], [2, 1, 0]]
max_value = 0
for order in orders:
    a, b, c = order
    max_value = max(max_value,max((ABC[a] * 10 + ABC[b]) + ABC[c], ABC[a] + (ABC[b] * 10 + ABC[c])))
print(max_value)

Solution (Python):

from sys import stdin

s = sorted([x for x in stdin.readline().rstrip().split()], reverse=True)

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

Solution (Python):

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

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):
number=[]
num_m=[]
number=input().split()

num_m=number
j=0
for j in range(2):
    i=0
    for i in range(2):
        if number[i]<number[i+1]:
            tmp=number[i]
            number[i]=number[i+1]
            number[i+1]=tmp

num_m[0]=int(number[0])*10
num_m[1]=int(number[1])
num_m[2]=int(number[2])
sum=0
sum=num_m[0]+num_m[1]+num_m[2]

print(sum)
n,j=0,0

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

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

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

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

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

Solution (Python):
def getinputdata():

    array_result = []    
    array_result.append(input().split(" "))

    flg = True

    try:
        while flg:

            data = input()

            if(data != ""):
                
                array_result.append(data.split(" "))

                flg = True

            else:

                flg = False
    finally:

        return array_result

arr_data = getinputdata()

arr=list(map(int, arr_data[0]))

arr.sort()

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

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

Solution (Python):
nums = sorted([int(inp) for inp in input().split(' ')])
nums.reverse()
print(int(str(nums[0]) + str(nums[1])) + nums[2])

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


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

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

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

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

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

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

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

Solution (Python):
from sys import stdin





a,b,c = [int(x) for x in stdin.readline().rstrip().split()]


ab_c = 10 * a + b + c

ba_c = 10 * b + a + c

ca_b = 10 * c + a + b


ret = max(ab_c, ba_c, ca_b)

print(ret)

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

abc.sort()
ans = int(str(abc[2]) + str(abc[1])) + int(abc[0])

print(ans)

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

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

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

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

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):
print((lambda x,y,z:x+y+z*10)(*sorted(map(int,input().split()))))

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

max = N[0]
max_index = 0

for i in range(len(N)):
    if N[i] > max:
        max = N[i]
        max_index = i

ans = N[max_index] * 10 + N[max_index - 1] + N[max_index - 2]

print(ans)

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


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

Solution (Python):
import sys


def solve(a,b,c):
    return ((max(a,b,c,)*10)+a+b+c-max(a,b,c))


def readQuestion():
    line = sys.stdin.readline().rstrip()
    [str_a, str_b, str_c] = line.split(' ')
    return (int(str_a), int(str_b), int(str_c))

def main():
    a, b, c = readQuestion()
    answer = solve(a, b, c)
    print(answer)
    
if __name__ == '__main__':
    main()

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

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

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

print(C*10 + A + B)

Solution (Python):


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

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

print d*9 + a + b + c

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

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

Solution (Python):
line = list(map(str, input().split()))
nline = sorted(line,reverse=True)

A = nline[0] + nline[1]
print(int(A) + int(nline[2]))

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

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

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

Solution (Python):
input_list = input().rstrip().split(' ')
max_num = max(input_list)
max_index = input_list.index(max_num)

big_str = str(input_list.pop(max_index))
big_str += str(input_list.pop())
big_num = int(big_str)
other_num = int(input_list.pop())

result = big_num + other_num
print(result)

Solution (Python):
s = input()
a = int(s.split()[0])
b = int(s.split()[1])
c = int(s.split()[2])
if a >= b and a >= c:
    ans = a*10 + b+c
if b >= a and b >=c:
    ans = b*10 + c + a
if c >=a and c>=b:
    ans = c*10 + a + b
    
print(int(ans))

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

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

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

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())); print(max(a) * 9 + sum(a))

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

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

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

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

Solution (Python):
def MaxNum(n1, n2):
    if int(n1) > int(n2):
        return int(n1 + n2)
    else:
        return int(n2 + n1)

if __name__ == '__main__':
    data = input().split()
    sum = list()

    sum.append(int(data[0]) + MaxNum(data[1], data[2]))
    sum.append(int(data[1]) + MaxNum(data[0], data[2]))
    sum.append(int(data[2]) + MaxNum(data[0], data[1]))

    print(max(sum))

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

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

Solution (Python):
num = input().split(" ")
number = [int(s) for s in num]
list = sorted(number, reverse = True)
sol = 10*list[0] + list[1] + list[2]
print(sol)

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

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

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

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

Solution (Python):

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


a = list(input().split())
a.sort(reverse=True)

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

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

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

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

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

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

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

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

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

Solution (Python):
num = list(map(int, input().split()))
num.sort()
num.reverse()
m_ = int(str(num[0]) + str(num[1]))
_m = num[2]
sum_ = m_ + _m
print(sum_)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 = list(map(int, input().split())); print(max(a) * 9 + sum(a))

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

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

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

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

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

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

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

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

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

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

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

Sum = a+b+c

Max = max(a,b,c)

print(Max*10+Sum-Max)

Solution (Python):
a = input().split()
a = [int(i) for i in a]
amax = a[0]
count = 0
for i in range(1,3):
    if a[i] > amax:
        amax = a[i]
        count = i
    else:
        pass
a.pop(count)
print(amax*10+a[0]+a[1])

Solution (Python):

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

Solution (Python):
A, B, C = list(map(int, input().split()))
ABC = [int(str(A)+str(B))+C, int(str(A)+str(C))+B, int(str(B)+str(A))+C, int(str(B)+str(C))+A, int(str(C)+str(A))+B, int(str(C)+str(A))+B]

print(max(ABC))

Solution (Python):
A, B, C = map(int, input().split())
X , Y, Z = sorted([A, B, C], reverse=True)
ans = 10 * X + Y + Z
print(ans)

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

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

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

data.sort(reverse=True)

answer = data[0] * 10 + data[1] + data[2]

print(answer)

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

print(n[0] +n[1] + n[2] + max(n) *9)

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

Solution (Python):
a1,a2,a3 = map(int,input().split())

list = [a1,a2,a3]
list.sort()

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

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

num = sorted([A,B,C],reverse=True)
print(eval(str(num[0])+str(num[1])+'+'+str(num[2])))

Solution (Python):
s = input().split(" ")
s = [int(i) for i in s]
m = max(s)
print(10*m + sum(s) - m)

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

Solution (Python):

x, y, z = map(int, input().split())
a =max( [ x, y, z ] )
if x == a:
	print (a*10 + y + z)
elif y == a:
	print (a*10 + z + x)
elif z == a:
	print (a*10 + x + y)

Solution (Python):
a = raw_input()
nums = a.split()
nums = [int(i) for i in nums]
nums.sort()
ans = nums[-1]*10 + nums[0] + nums[1]
print(ans)

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

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

Solution (Python):
import io
import sys




def solve(a):
    list1 = sorted(a)
    ab = str(list1[2])+str(list1[1])
    return int(ab)+int(list1[0])


def readQuestion():

    line = sys.stdin.readline().rstrip()
    listabc = line.split(" ")
    return listabc

def main():
    n = readQuestion()
    answer = solve(n)
    print(answer)
    
if __name__ == '__main__':
    main()

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()))
l.sort(reverse=True)

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

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

ma=max(li)
li.remove(ma)

print(ma*10+li.pop()+li.pop())

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

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

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

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

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

Solution (Python):



def main():
    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)
    elif C >= B and C >= A:
        print(10 * C + A + B)


if __name__ == "__main__":
    main()

Solution (Python):
import numpy as np
 
inp = np.asarray(input().split(), dtype=int)
inp = np.sort(inp)
print(np.sum(inp)+inp[2]*9)

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

a = sorted(a)

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

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

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

answer = max(A,B,C)*10 + (A+B+C-max(A,B,C))

print(answer)

Solution (Python):
print(eval(''.join(sorted(input()+'++')*4)[6::5]))

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

Solution (Python):
*x,=map(int,input()[::2]);print(max(x)*9+sum(x))

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

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

print(max(ans))

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

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

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

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

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

max_lines = [[x * 10 + y, z],
                 [x * 10 + z, y],
                 [y * 10 + x, z],
                 [y * 10 + z, x],
                 [z * 10 + x, y],
                 [z * 10 + y, x]]

max_point = 0
one_point = 0
for max_line in max_lines:
    if max_line[0] >= max_point:
        max_point = max_line[0]
        one_point = max_line[1]

print(max_point + one_point)

Solution (Python):
a = input()
b = []

for x in a:
    if x == " ":
        pass
    else:
        b.append(int(x))












b0_str = str(b[0])
b1_str = str(b[1])
b2_str = str(b[2])


b01_str = b0_str + b1_str
ab_c = int(b01_str) + b[2]


b02_str = b0_str + b2_str
ac_b = int(b02_str) + b[1]


b10_str = b1_str + b0_str
ba_c = int(b10_str) + b[2]


b12_str = b1_str + b2_str
bc_a = int(b12_str) + b[0]


b20_str = b2_str + b0_str
ca_b = int(b20_str) + b[1]


b21_str = b2_str + b1_str
cb_a = int(b21_str) + b[0]

max_ans = 0
if max_ans < ab_c:
    max_ans = ab_c
if max_ans < ac_b:
    max_ans = ac_b
if max_ans < ba_c:
    max_ans = ba_c
if max_ans < bc_a:
    max_ans = bc_a
if max_ans < ca_b:
    max_ans = ca_b
if max_ans < cb_a:
    max_ans = cb_a

print(max_ans)

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

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

Solution (Python):

x = list(map(int,input().split()))
Max = max(x)
x.remove(Max)
Sum = sum(x)
Sum = Sum + (Max * 10)
print(Sum)

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

Solution (Python):

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

print(10 * abc[-1] + abc[-2] + abc[-3])

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

a = max(l)
l.remove(a)
print(a*10 + l[0] + l[1])

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

xs = list(reversed(xs))

head = int( ''.join([str(x) for x in xs[0:2]]) )
tail = xs[-1]

print(head + tail)

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

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

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

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)


def main():
    a = LI()
    t = max(a)

    return t * 9 + sum(a)


print(main())

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

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

Solution (Python):
import itertools

n = list(map(str, raw_input().split()))
n.append('+')
nc = list(itertools.permutations(n))
ncc = []
vn = []
for _ in nc:
    if _[0] != '+' and _[3] != '+':
        ncc.append(_)
for __ in ncc:
    v = eval(('').join(__))
    vn.append(v)
print(max(vn))

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

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

def ans1(): 
    return max([
        10*A + B + C, 
        10*B + A + C, 
        10*C + A + B, 
    ])

def ans2():
    return A + B + C + 9*max([A, B, C])


print(ans2())

Solution (Python):
a, b, c = input()[::2]

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

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

Solution (Python):


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

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

Solution (Python):




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

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


if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

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

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

Solution (Python):



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

if a > b:
	if a > c:
		print("{}".format((a*10)+b+c))
	else:
		print("{}".format(a+b+(c*10)))
else:
	if b > c:
		print("{}".format(a+(b*10)+c))
	else:
		print("{}".format(a+b+(c*10)))

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

m = max(L)
i = L.index(m)
score=m*10
for j in range(3):
    if j!=i:
        score+=L[j]
print score

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

Solution (Python):
x = input().split(' ')
x.sort()
x.reverse()
result = int(x[0])*10 + int(x[1]) + int(x[2])
print(result)

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

arr.sort()

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

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

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

Solution (Python):

from sys import stdin

s_in = lambda: stdin.readline()[:-1] 
d_in = lambda: int(stdin.readline()) 
ds_in = lambda: list(map(int, stdin.readline().split())) 

A, B, C = ds_in()
print(max(A, B, C) * (10-1) + (A+B+C))

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

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

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

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

num.sort(reverse = True)


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

print(ans)

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

Solution (Python):

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

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

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

print(ans)

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

Solution (Python):

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

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

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

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

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

Solution (Python):
def main():
    a, b, c = map(int, input().split())
    arr = sorted([a, b, c])

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

main()

Solution (Python):
a, b, c = input().split()
hoge = [a, b, c]
hoge.sort()
hoge.reverse()
x, y, z = hoge
A = int(x + y)
B = int(z)
print(A+B)

Solution (Python):
from itertools import permutations

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

D = -1
for a, b, c in permutations([A, B, C], 3):
    D = max(a * 10 + b + c, D)

print(D)

Solution (Python):
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(10*b + a + c)
else:
    print(10*c + a + b)

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

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

Solution (Python):
A = [int(i) for i in input().split()]
A.sort(reverse=True)
A[0] *= 10

print(sum(A))

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

Solution (Python):

x, y,z = map(int, input().split())

arr = [x,y,z]

arr.sort()
arr.reverse()



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

Solution (Python):
import itertools
a =list(itertools.permutations( list(input().split())))
b =[]
for i in range(len(a)):  
    c = a[i][0] + a[i][1]
    d = int(c) + int(a[i][2])
    b.append(d)
print(max(b))

Solution (Python):


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


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

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

li=[A,B,C]

max_num=max(li)
max_num2=min(li)

for i in li:
    if max_num!=i and max_num2<i:
        max_num2=i
        
num1=int(str(max_num)+str(max_num2))
li.remove(max_num)
li.remove(max_num2)

print(int(num1)+li[0])

Solution (Python):
s = input()

num = list(s)

num.sort()
num.reverse()

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

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

Solution (Python):
import numpy as np,math,itertools

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

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

max = 0

for i in range(len(A)):
    if max < (A[i] * 10 + A[(i+1)%len(A)] + A[(i+2)%len(A)]):
        max = A[i] * 10 + A[(i+1)%len(A)] + A[(i+2)%len(A)]
    if max < (A[i] + A[(i+1)%len(A)]*10 + A[(i+2)%len(A)]):
        max = (A[i] + A[(i+1)%len(A)]*10 + A[(i+2)%len(A)])

print max

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

Solution (Python):
a=map(str, raw_input().split())

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

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

Solution (Python):
panels = map(int, raw_input().split())
panels = sorted(panels)

print 10 * panels[-1] + panels[-2] + panels[-3]

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

N.sort()

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

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

a.sort()

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

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

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

x = sorted(x, reverse=True)

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

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

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

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

Solution (Python):


A, B, C = map(int, input().split()) 
res = 10 * A + B + C
if A + 10 * B + C > res:
    res = A + 10 * B + C
if A + B + 10 * C > res:
    res = A + B + 10 * C

print(res)

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

Solution (Python):
panel_nums_str = input().split(" ")

panel_nums = []
for num in panel_nums_str:
    panel_nums.append(int(num))

panel_nums.sort()

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

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

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):
iA,iB,iC =sorted([int(x) for x in input().split()])
print(10*iC+iB+iA)

Solution (Python):
num = input().split()
num.sort()
num.reverse()

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

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

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

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

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

print(ans)