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=input().split()

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

if a>=b:
  if a>=c:
    x=a
    if b>=c:
      y=b
      z=c
    else:
        y=c
        z=b
  else:
      x=c
      y=a
      z=b
else:
  if b>=c:
    x=b
    if a>=c:
      y=a
      z=c
    else:
        y=c
        z=a
  else:
      x=c
      y=b
      z=a

n=x*10+y+z
print(n)

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

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

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

Solution (Python):


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

a.sort()

b, c, d = a

print(d * 10 + c + b)

Solution (Python):
list_str = input().split()
list=[int(n) for n in list_str]
list.sort(reverse=True)

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

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

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

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

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

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

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

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

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

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

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

x.sort()

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

Solution (Python):
A, B, C = list(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):

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

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

Solution (Python):
lis = input().split()
lis = sorted(lis, key=lambda x: int(x), reverse=True)
print(int(''.join(lis[:2])) + int(lis[2]))

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

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

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

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

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

from itertools import permutations, combinations,combinations_with_replacement,product

c = list(permutations(a))

i = c[0]
first = int(str(i[0])+str(i[1]))

x = first+i[2]


maxnum = 0
for i in c:
    first = int(str(i[0])+str(i[1]))
    after = i[2]
    x = first + after

    if x > maxnum:
        maxnum = x

print(maxnum)

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

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

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

Solution (Python):
a, b, c = [int(elem) for elem in input().split()]
res = max(a, b, c) * 10 + a + b + c - max(a, b, c)
print(res)

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

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

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

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

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

ans = []

ans.append(10*a+b+c)
ans.append(10*b+c+a)
ans.append(10*c+a+b)

print(max(ans))

Solution (Python):
a=list(input().split())
a.sort()
aa=a[::-1]
b=aa.pop()
c="".join(aa)
print(int(b)+int(c))

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

Solution (Python):
L=list(int(i) for i in input().split())
print(max(L)*10+sum(L)-max(L))

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

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

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

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

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

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

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

cards.sort(reverse = True)
ans = cards[0]*10 + cards[1] + cards[2]

print(ans)

Solution (Python):
a,b,c = input().split()
print(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)))

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

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

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
mod = 1000000007
sys.setrecursionlimit(1000000)


def A():
    s = LI()
    s.sort(reverse = True)
    print(10*s[0]+s[1]+s[2])
    return


def B():
    return


def C():
    s = S()
    t = S()
    n = len(s)
    d = defaultdict(list)
    for i in range(n):
        d[s[i]].append(t[i])
    d2 = defaultdict(list)
    for i in range(n):
        d2[t[i]].append(s[i])
    for i in d.keys():
        k = d[i]
        k = list(set(d[i]))
        if len(k) > 1:
            print("No")
            quit()
    for i in d2.keys():
        k = d2[i]
        k = list(set(d2[i]))
        if len(k) > 1:
            print("No")
            quit()
    print("Yes")

def D():
    n,m = LI()
    if m == 1:
        print(1)
        quit()
    d = defaultdict(int)
    i = 2
    a = m
    while i**2 <= m:
        if not a%i:
            while not a%i:
                a//=i
                d[i] += 1
        i += 1
    if a != 1:
        d[a] += 1
    fact = [1 for i in range(n+31)]
    for i in range(n+30):
        fact[i+1] = fact[i]*(i+1)%mod
    inv_fact = [None for i in range(n+31)]
    inv_fact[n+30] = pow(fact[n+30],mod-2,mod)
    for i in range(n+30)[::-1]:
        inv_fact[i] = inv_fact[i+1]*(i+1)%mod
    ans = 1
    for i in d.values():
        ans *= fact[i+n-1]*inv_fact[i]*inv_fact[n-1]%mod
        ans %= mod
    print(ans)

def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == "__main__":
    A()

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

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

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

Solution (Python):
import numpy as np

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

output=[]
output.append(A+B*10+C)
output.append(A+C*10+B)
output.append(B+A*10+C)
output.append(B+C*10+A)
output.append(C+A*10+B)
output.append(C+B*10+A)

print(np.max(np.array(output)))

Solution (Python):
a=input();print(eval('+'.join(a+max(a)*9)))

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

Solution (Python):


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

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

print(a + b + c * 10)

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

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

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

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

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

Solution (Python):

n = map(int, input().split())

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

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

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

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

Solution (Python):
num = [int(i) for i in input().split()]
num.sort()
print(sum(num)+num[-1]*9)

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

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

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

Solution (Python):
N = [int(x) for x in input().split()]
N.sort()
print(sum(N) + N[-1] * 9)

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

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

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

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

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

l.sort(reverse=True)

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

print(int(str(a[0])+str(a[1]))+int(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())
big = a
go = b
if big < b:
    big = b
if big < c:
    big = c

if big == b:
    go = a + c
elif big == c:
    go = b + a
else:
    go = b + c
print big * 10 + go

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

Solution (Python):
abc = sorted(list(map(int,input().split())))[::-1]
print(int(str(abc[0])+str(abc[1])) + abc[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(map(int,input().split()));print(sum(a)+max(a)*9)

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

Solution (Python):
a = [int(i) for i in input().split()]
a = sorted(a)
ans = a[-1]*9+sum(a)
print(ans)

Solution (Python):
L=input().split()
L.sort(reverse=True)
A=int(L[0])
B=int(L[1])
C=int(L[2])
print(A*10+B+C)

Solution (Python):
_in = list(map(int, input().split(' ')))
_in = sorted(_in)
a = int('{}{}'.format(_in[-1], _in[-2]))
print('{}'.format(_in[0] + a))

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

ans = l.pop(l.index(max(l)))*10
ans += sum(l)

print(ans)

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

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

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


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

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

Solution (Python):
import itertools

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

 
list=[]
list.append(A*10+B+C)
list.append(A*10+C+B)
list.append(B*10+A+C)
list.append(B*10+C+A)
list.append(C*10+A+B)
list.append(C*10+B+A)

list.append(A+B*10+C)
list.append(A+C*10+B)
list.append(B+A*10+C)
list.append(B+C*10+A)
list.append(C+A*10+B)
list.append(C+B*10+A)


print(max(list))

Solution (Python):
import itertools

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

 
list=[]
list.append(A*10+B+C)
list.append(A*10+C+B)
list.append(B*10+A+C)
list.append(B*10+C+A)
list.append(C*10+A+B)
list.append(C*10+B+A)

list.append(A+B*10+C)
list.append(A+C*10+B)
list.append(B+A*10+C)
list.append(B+C*10+A)
list.append(C+A*10+B)
list.append(C+B*10+A)


print(max(list))

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

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

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

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

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

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

nums.sort(reverse=True)

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

Solution (Python):
print(eval("{}{}+{}".format(*sorted(input().split())[::-1])))

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

Solution (Python):
abc=input().split()
a=int(abc[0]);b=int(abc[1]);c=int(abc[2])
abc=[a,b,c]
mx=max(abc)*10
abc.remove(max(abc))
print(str(abc[0]+abc[1]+mx))

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

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

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

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

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

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

Solution (Python):
i = list(map(int, input().split()))
i.sort(reverse=True)
A = i[0]
B = i[1]
C = i[2]

AB = str(A) + str(B)
D = int(AB) + C

print(D)

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

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

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

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

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

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

Solution (Python):


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

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

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

Solution (Python):

N = sorted(input().split(), reverse=True)
print(int(N[0] + N[1]) + int(N[2]))

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

max_a = max(a)
a[a.index(max(a))] = 0

print(max_a*10 + sum(a))

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

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

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())
temp=0

if a<b:
	temp=b
	b=a
	a=temp
if a<c:
	temp=c
	c=a
	a=temp

print(10*a+b+c)

Solution (Python):
tmp = [int(i) for i in raw_input().split()]
A = max(tmp)
tmp.remove(A)
B = max(tmp)
tmp.remove(B)
C = max(tmp)

print(10*A + B + C)

Solution (Python):
a,b,c = map(int,input().split())
ab = 10*a+b+c
ac = 10*a+c+b
ba = 10*b+a+c
bc = 10*b+c+a
ca = 10*c+a+b
cb = 10*c+b+a
lists = [ab,ac,ba,bc,ca,cb]
print(max(lists))

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):
n = sorted([int(_) for _ in input().split()],reverse = True)
ans = n[0] * 10 + n[1] + n[2]
print(ans)

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

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

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

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

Solution (Python):
def main():
    inputs = sorted(input().split())
    fst = inputs[-1]
    lst = inputs[0]
    mid = inputs[1]

    print(eval('{}{} + {}'.format(fst, mid, lst)))


if __name__ == "__main__":
    main()

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

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

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

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

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

Solution (Python):
ri = lambda: int(input())
rl = lambda: list(map(int,input().split()))
rr = lambda N: [ri() for _ in range(N)]
YN = lambda b: print('YES') if b else print('NO')
yn = lambda b: print('Yes') if b else print('No')
OE = lambda x: print('Odd') if x%2 else print('Even')
INF = 10**18

a,b,c=rl()

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

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

Solution (Python):
def maximize_the_formula(A: int, B: int, C: int) -> int:
    x, y, z = sorted([A, B, C], reverse=True)
    return 10 * x + y + z


if __name__ == "__main__":
    A, B, C = map(int, input().split())
    ans = maximize_the_formula(A, B, C)
    print(ans)

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

Solution (Python):


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

Solution (Python):


A, B, C = map(int, input().split())
L = [A, B, C]
L.sort()

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

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

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

l = [10*a + b+c,10*b+a+c,10*c+a+b]

print(max(l))

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

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

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

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

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

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

print(ans)
print()

Solution (Python):

a, b, c = [int(x) for x in input().split()]
li = sorted([a, b, c])
print(li[-1] * 10 + li[0] + li[1])

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

AB = max(int(A+B),int(B+A))
AC = max(int(A+C),int(C+A))
BC = max(int(B+C),int(C+B))
A,B,C = map(int,[A,B,C])
print(max([A+BC,B+AC,C+AB]))

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

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

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

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

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

ret = max(a,b,c)
if ret==a:
    ans = 10*a+b+c
elif ret==b:
    ans = 10*b+a+c
elif ret==c:
    ans = 10*c+b+a
print(ans)

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

Solution (Python):
def solve(string):
    a = sorted(map(int, string.split()))
    return str(a[-1] * 10 + a[1] + a[0])


if __name__ == '__main__':
    print(solve(input()))

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

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

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

nmax = max(n)
n.remove(nmax)
ans = nmax * 10 + sum(n) 
print(ans)

Solution (Python):
import itertools, copy

n = input().split()

ans = 0
for p0, p1 in itertools.permutations(n, 2):
    n_ = copy.copy(n)
    n_.remove(p0)
    n_.remove(p1)
    
    total = int(''.join([p0, p1])) + int(n_[0])
    ans = max(ans, total)

print(ans)

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

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

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

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

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

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

List = []
List.append(A)
List.append(B)
List.append(C)

big_digit = str(max(List))
del List[List.index(max(List))]

small_digit = str(List[0])

num = big_digit + small_digit
num = int(num)

print(num + List[1])

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

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

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

x = str(max(l)) + str(min(l))
x = int(x)

l.remove(max(l))
l.remove(min(l))
y = int(l.pop(0))

print(x+y)

Solution (Python):
from sys import stdin

a, b, c = sorted([int(x) for x in stdin.readline().rstrip().split()], reverse=True)
print(a*10+b+c)

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

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

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

Solution (Python):
a=list(sorted(input().split()))[::-1];a.insert(2,"+");print(eval("".join(a)))

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

Solution (Python):
from sys import stdin
a, b, c = [int(i) for i in stdin.readline().rstrip().split()]

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

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

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

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

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

a = int(str(n[0]) + str(n[1]))

print(a+n[2],end='')

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

Solution (Python):


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

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

if y <= x and z <= x:
    print(x)
elif y <= z and x <= z:
    print(z)
else:
    print(y)

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

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

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

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


if __name__ == '__main__':
    main()

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

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

print(inputs[0] * 10 + inputs[1] + inputs[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):
values = raw_input()
values = [int(i) for i in values.split(" ")]
values = sorted(values, reverse=True)
print(int(str(values[0])+str(values[1]))+values[-1])

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

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

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

sequence.sort(reverse = True)
A = str(sequence.pop(0))
A += str(sequence.pop(0))
B = sequence.pop(0)
C = int(A) + B
print(C)

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

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

n.sort()
big = int(str(n[2])+str(n[1]))
mini = n[0]

print(big+mini)

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

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

Solution (Python):
values = raw_input()
values = [int(i) for i in values.split(" ")]
values = sorted(values)
print(str(int(str(values[2])+str(values[1]))+values[0]))

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

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

Solution (Python):
import numpy as np

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

output=[]
output.append(A+B*10+C)
output.append(A+C*10+B)
output.append(B+A*10+C)
output.append(B+C*10+A)
output.append(C+A*10+B)
output.append(C+B*10+A)

print(np.max(np.array(output)))

Solution (Python):

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

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

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

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

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

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

print(first + second)

Solution (Python):
import sys

def main():
  input = sys.stdin.readline
  N = list(map(int, input().split()))
  N = sorted(N)
  print(N[2] * 10 + N[1] + N[0])


if __name__ == '__main__':
  main()

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

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

Solution (Python):
nums = [int(n) for n in input().split()]
nums.sort()
X = int(str(nums[2]) + str(nums[1]))
Y = nums[0]
print(X+Y)

Solution (Python):
abc = list(input().split())
abc.sort(reverse=True)
ans = int(abc[0]+abc[1])+int(abc[2])
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):
print(eval('+'.join(sorted(input()))+'*10'))

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

Solution (Python):




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

max = -1
min = 10
maxidx = -1
minidx = -1


for i in range(3):
    if abc[i] > max:
        max = abc[i]
        maxidx = i


abc[maxidx] = abc[maxidx]*10


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


print(ans)

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

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

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

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

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

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

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

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

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

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

Solution (Python):



s= ( map(int, raw_input().split()) )
s = sorted(s, reverse=True)
print int( str(s[0]) + str(s[1]) ) + (s[2])

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

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

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

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

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