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 = list(map(int, input().split()))
a = sorted(a)
b = [str(a[2]), str(a[1])]
c = ''.join(b)
print(int(c) + a[0])

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

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

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

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

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

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

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

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

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

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

Solution (Python):

Ns = list(map(int, input().split()))
Ns.sort(reverse=True)

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

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

sum = a + b + c
v1 = sum + 9*a
v2 = sum + 9*b
v3 = sum + 9*c
print(max([v1,v2,v3]))

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

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

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

given_list.sort()
given_list[-1] = given_list[-1] * 10
print(sum(given_list))

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

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

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

Solution (Python):
s=''.join(input().split())
ss = sorted(s,reverse=True)
ret = "{}*10+{}+{}".format(ss[0],ss[1],ss[2])
print(eval(ret))

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

x = 10*a+b+c
y = 10*b+a+c
z = 10*c+a+b
print(max(x,y,z))

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

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

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

Solution (Python):


abc = [int(i) for i in input().split()]

abc.sort()

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

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

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

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

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

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

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

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

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

Solution (Python):

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

list.sort(reverse=True)

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

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

Solution (Python):
def main():
    l = list(map(int,input().split()))
    l = sorted(l,reverse=True)
    ans = ''

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


    '''
    for i in range(0,len(l)-1):
        ans = ans + str(l[i])
    ans_int = int(ans) + int(l[-1])

    print(ans_int)
    '''




if __name__ == '__main__' :
    main()

Solution (Python):
def main():
    l = list(map(int,input().split()))
    l = sorted(l,reverse=True)
    ans = ''

    for i in range(0,len(l)-1):
        ans = ans + str(l[i])
    ans_int = int(ans) + int(l[-1])

    print(ans_int)




if __name__ == '__main__' :
    main()

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

Solution (Python):

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

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

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

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

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

Solution (Python):


li = list(map(int, input().rstrip().split()))
li.sort()

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

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

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

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

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

p=max(A,B,C)

print(p*9+A+B+C)

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

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

Solution (Python):



if __name__ == '__main__':
    a, b, c = sorted(map(int, input().split(' ')))
    print(10 * c + b + a)

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

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

Solution (Python):
import itertools

a,b,c = map(int,input().split())
abc = list(itertools.permutations([a,b,c]))



max_sum = 0

for i in range(len(abc)):
    max_tmp = abc[i][0]*10+abc[i][1]+abc[i][2]
    if max_tmp > max_sum:
        max_sum = max_tmp

print(max_sum)

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

Solution (Python):
Tmp = []
Tmp = input().rstrip().split(' ')
 
Ans = []
 
nA = int(Tmp[0])
Ans.append(nA)
 
nB = int(Tmp[1])
Ans.append(nB)
  
nC = int(Tmp[2])
Ans.append(nC)
 
Ans.sort(reverse=True)
 
nAns = Ans[0]*10+Ans[1]+Ans[2]
print(nAns)

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

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

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

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

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

Solution (Python):
from copy import deepcopy
from sys import exit,setrecursionlimit
import math
from collections import defaultdict,Counter,deque
from fractions import Fraction as frac

setrecursionlimit(1000000)


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

def zip(a):
	mae = a[0]
	ziparray = [mae]
	for i in range(1,len(a)):
		if(mae != a[i]):
			ziparray.append(a[i])
			mae = a[i]
	return ziparray

def is_prime(n):
	if n < 2: return False

	for k in range(2, int(math.sqrt(n)) + 1):
		if n % k == 0:
			return False

	return True

def list_replace(n,f,t):
	return [t if i==f else i for i in n]

def base_10_to_n(X, n):
	X_dumy = X
	out = ''
	while X_dumy>0:
		out = str(X_dumy%n)+out
		X_dumy = int(X_dumy/n)
	if(out == ''): return '0'
	return out

def gcd(l):
	x = l.pop()
	y = l.pop()
	while(x%y!=0):
		z = x%y
		x = y
		y = z
	l.append(min(x,y))
	return gcd(l) if len(l) > 1 else l[0]

class Queue():
	def __init__(self):
		self.q = deque([])
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.popleft()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class Stack():
	def __init__(self):
		self.q = []
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.pop()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class graph():
	def __init__(self):
		self.graph = defaultdict(list)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
		self.graph[t].append(f)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
		self.graph[t].remove(f)
	def linked(self,f):
		return self.graph[f]

class dgraph():
	def __init__(self):
		self.graph = defaultdict(set)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
	def linked(self,f):
		return self.graph[f]

main()

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

Solution (Python):


def main():
    target = input().split()
    target.sort(reverse=True)
    left = target[:2]
    right = target[-1]
    print(int(''.join(left))+int(right[0]))




     


        
    
if __name__== "__main__":
    main()

Solution (Python):
abc = input().split(' ')
nums = []
nums.append(int(abc[0] + abc[1]) + int(abc[2]))
nums.append(int(abc[1] + abc[0]) + int(abc[2]))
nums.append(int(abc[0]) + int(abc[1] + abc[2]))
nums.append(int(abc[0]) + int(abc[2] + abc[1]))
nums.append(int(abc[0] + abc[2]) + int(abc[1]))
nums.append(int(abc[2] + abc[0]) + int(abc[1]))
print(max(nums))

Solution (Python):
l = [int(i) for i in input().split()]
m = []
for i in range(3):
    m.append(10*l[i]+l[i-1]+l[i-2])
print(max(m))

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

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

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

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

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

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

Solution (Python):

lst = list(map(str, input().split()))
sorted_lst = sorted(lst, reverse=True)
print(int("".join(sorted_lst[0:2])) + int(sorted_lst[2]))

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

Solution (Python):
l = [int(i) for i in input().split(" ")]
total = max(l)*9 + sum(l)
print(total)

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

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

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

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

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

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

Solution (Python):
n=sorted(input())[::-1];print(eval(n[0]+n[1])+int(n[2]))

Solution (Python):

x =map(int,input().split())
x = sorted(x, reverse=True)

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

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

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

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

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

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

Solution (Python):



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

abc.sort(reverse=True)







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

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

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):
ABC = list(map(int, input().split()))
mi = ABC.pop(ABC.index(min(ABC)))
ma = ABC.pop(ABC.index(max(ABC)))
print((ma * 10) + ABC[0] + mi)

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

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

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

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

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

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

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

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())
print(A+B+C+9*max(A,B,C))

Solution (Python):
import statistics
N = list(map(int,input().split()))
A = max(N)
B = min(N)
C = sum(N)-A-B
print(A*10+B+C)

Solution (Python):



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


l.sort()


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

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

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

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

a.sort()

out = a[-1] * 10 + a[0] + a[1]

print(out)

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

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

Solution (Python):
nums = list(map(int, input().split()))
nums.sort(key=lambda x: -x)
print(int(str(nums[0]) + str(nums[1])) + nums[2])

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

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

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

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

y=sorted(x)

res=y[2]*10+y[0]+y[1]

print(res)

Solution (Python):
a,b,c =map(int,input().split())
l = [a,b,c]
l.sort()

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

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

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

nums.sort()
nums.reverse()

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

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

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

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

max = max([A,B,C])
print(sum([A,B,C])-max+max*10)

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def A():
    a = LI()
    a.sort()
    a, b, c = a
    print(int(str(c)+str(b))+a)
    return


def B():
    return


def C():
    return


def D():
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == '__main__':
    A()

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

Solution (Python):

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

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

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

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

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

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

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

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

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

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

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

b = sorted(a)

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

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

Solution (Python):
l=sorted(list(input().split()),reverse=True)
l.insert(2,"+")
print(eval("".join(l)))

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

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

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

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

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

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

Solution (Python):

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

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

resolve()

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

ABC.sort()

answer = ABC[-1]*10 + sum(ABC[:2])

print(answer)

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

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

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

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

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

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

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

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

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

from functools import reduce

lst = [10*A+B+C, 10*A+C+B, 10*B+A+C, 10*B+C+A, 10*C+A+B, 10*C+B+A]

print(reduce(max, lst))

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
MOD = 1000000007
def POW(x, y): return pow(x, y, MOD)
def INV(x, m=MOD): return pow(x, m - 2, m)
def DIV(x, y, m=MOD): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(input())

A,B,C=LI()

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

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

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

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

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

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

Solution (Python):
X = input().split()
formulas = []
formulas.append(''.join(X[0]+X[1]+"+"+X[2]))
formulas.append(''.join(X[1]+X[2]+"+"+X[0]))
formulas.append(''.join(X[2]+X[0]+"+"+X[1]))
print(max([eval(x) for x in formulas]))

Solution (Python):
nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(input())
s = lambda: input()

A, B, C = sorted(nl(), reverse=True)
print(int(str(A) + str(B)) + C)

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

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

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

nums.sort()



A = 10 * int(nums[2]) + int(nums[1])
B = int(nums[0])

print(A + B)

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

Solution (Python):
dig = input().split()
dig.sort()
print(eval(dig[2] + dig[1] + '+' + dig[0]))

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

Solution (Python):
a=input().split()
for i in range(3):
   a[i]=int(a[i])
s=9*max(a)+sum(a)
print(s)

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

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

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

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

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

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

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

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

Solution (Python):

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


answer = 0
first_max = max(num)
num.remove(first_max)
second_max = max(num)
num.remove(second_max)
third_max = max(num)

answer = int(str(first_max) + str(second_max)) + third_max



print(answer)

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

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

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

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

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

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

Solution (Python):

import sys


def solve(A: int, B: int, C: int):
    a = [A, B, C]
    a = sorted(a, reverse=True)
    print(a[0]*10 + a[1] + a[2])
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    C = int(next(tokens))  
    solve(A, B, C)

if __name__ == '__main__':
    main()

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

Solution (Python):
a,b,c= map(int, input().split())
m = max([a,b,c])
print(m*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())
print(max(a,b,c)*9+a+b+c)

Solution (Python):

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

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

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

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

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

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

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

abc()

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

abc()

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

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

print(ans)

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

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

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

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

Solution (Python):
ABC = list(map(int, input().split()))
sum = 0
sum += max(ABC)*10
index = ABC.index(max(ABC))
for i in range(3):
    if i != index:
        sum += ABC[i]
print(sum)

Solution (Python):
ABC = list(map(int, input().split()))
sum = 0
sum += max(ABC)*10
index = ABC.index(max(ABC))
for i in range(3):
    if i != index:
        sum += ABC[i]
print(sum)

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

Solution (Python):
A, B, C = input().split()
result = 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(result)

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

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

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

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

li = [A, B, C]
li.sort(reverse=True)

tmp = str(li[0])+str(li[1])

print(int(tmp)+li[2])

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

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

num_list = [A,B,C]
num_list.sort(reverse=True)


left = str(num_list[0]) + str(num_list[1])

left = int(left)

print(left + num_list[2])

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

ls.sort()

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

Solution (Python):



import sys

input = sys.stdin.readline

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

main()

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

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

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

li = []

li.append(A)
li.append(B)
li.append(C)

reli = sorted(li, reverse=True)

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

print(num)

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

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

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

Solution (Python):


x = list(map(int, input().split(' ')))
x.sort(reverse = True)

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

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

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

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

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

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

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

sli = sorted(li, reverse=True)
re = str(sli[0]) + str(sli[1])
re = int(re) + sli[2]
print(re)

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

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

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

ABC.sort(reverse=True)

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

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

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

ans = 0

ans += max(A)*10
A.remove(max(A))
ans += A[0]+A[1]
print(ans)

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

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

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

Solution (Python):
L=list(map(int,input().split()))
A=[]
for i in range(2):
  n=L[i]+L[i-2]*10+L[i-1]
  m=L[i]+L[i-2]+L[i-1]*10
  A.append(n)
  A.append(m)
print(max(A))

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

Solution (Python):

lst_A = input().split()

lst_A.sort()

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

print(ans)

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

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

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

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

nums=sorted(nums,reverse=True)

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