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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import math

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

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

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

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

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

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

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

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

x = []
for i in range(2):
  x.append(str(l[i]))

y = int(''.join(x))
z = l[2]

print(y + z)

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

L = sorted(L,reverse=True)
L = list(map(str,L))

print(max(eval(L[0] + "+" + L[1] + L[2]),eval(L[0]  + L[1] + "+" + L[2])))

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

x = []
for i in range(2):
  x.append(str(l[i]))

y = int(''.join(x))
z = l[2]

print(y + z)

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

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

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

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

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

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

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

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

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

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

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

a.sort()

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

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

A=10*a+b+c
B=a+10*b+c
C=a+b+10*c
print(max(A,B,C))

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

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

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

Solution (Python):
import sys
import numpy as np
input = sys.stdin.readline
A = [str(x) for x in input().split()]
A = sorted(A,reverse=True)
a = int("".join(A[:2]))
b = int(A[2])
print(a + b)

Solution (Python):
a, b, c = [int(x) for x in input().split()]
A, B, C = sorted([a,b,c], reverse=True)
print(A*10+B+C)

Solution (Python):
a, b, c = [x for x in input().split()]
sum1 = int(a)+int(b+c)
sum2 = int(a)+int(c+b)
sum3 = int(b)+int(a+c)
sum4 = int(b)+int(c+a)
sum5 = int(c)+int(a+b)
sum6 = int(c)+int(b+a)
print(max(sum1, sum2, sum3, sum4, sum5, sum6))

Solution (Python):
a, b, c = [int(x) for x in input().split()]
sum1 = a+(b*10+c)
sum2 = a+(c*10+b)
sum3 = b+(a*10+c)
sum4 = b+(c*10+a)
sum5 = c+(a*10+b)
sum6 = c+(b*10+a)
print(max(sum1, sum2, sum3, sum4, sum5, sum6))

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

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

print(tmp + A[0])

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

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

print(10 * C + B + A)

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

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

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

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

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

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

Solution (Python):
a,b,c = sorted(input().split(),reverse=True)
print(max(eval(a + "+" + b + c),eval(a + b + "+" + c)))

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

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

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

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

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

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

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

li = sorted(li)

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

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

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

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

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

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

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

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

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

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

Solution (Python):

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

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

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

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

Solution (Python):
a, b, c = (int(x) for x in 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):
def main():
    array = [int(x) for x in list(input().split())]
    array_sorted = sorted(array)
    print(array_sorted[-1]*10+array_sorted[-2]+array_sorted[-3])


if __name__ == '__main__':
    main()

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


data.sort()

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

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

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

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

ss = sorted(s)
print(ss[-1]*10+ss[-2]+ss[-3])

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

Solution (Python):


V=input().split(" ")
Vs=list(reversed(sorted(V)))
print(int("".join(Vs[:2]))+int(Vs[2]))

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

Solution (Python):

import math





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

l = []
l.append(A)
l.append(B)
l.append(C)
l.sort()

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

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

print(keta + list1[-1])

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

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

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

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

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

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

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

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

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

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

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

l=[A,B,C]
l=sorted(l)

ans=TTL+l[2]*9
print(ans)

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

nums = [A, B, C]

nums.sort(reverse=True)

ans = str(nums[0])+str(nums[1])

print(int(ans)+nums[2])

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

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

Solution (Python):
list = map(int, input().split())
anslist = sorted(list, reverse = True)
print(anslist[0]*10 + anslist[1] + anslist[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, b, c = map(int, input().split())
nums = [a, b, c]
nums.sort(reverse=True)
ans = str(nums[0])+str(nums[1])
print(int(ans)+nums[2])

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

yen = [A , B , C]

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

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

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

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

print(ans)

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

li = sorted(li)

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

Solution (Python):

si = lambda: input()
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))
a,b,c = map(int, input().split())
ans = ''
max_s = max(a,b,c)

if max_s == a:
    ans = 10*a+b+c
elif max_s == b:
    ans = 10*b+c+a
elif max_s == c:
    ans = 10*c+a+b
print(ans)

Solution (Python):

si = lambda: input()
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))
a,b,c = map(int, input().split())
ans = ''
max_s = max(a,b,c)

if max_s == a:
    ans = 10*a+b+c
elif max_s == b:
    ans = 10*b+c+a
elif max_s == c:
    ans = 10*c+a+b
print(ans)

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

Solution (Python):

import sys


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



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):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

A, B, C = MAP()

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy,copy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

def main():
    a, b, c = MAP()
    print(max(a*10 + b + c, a + b*10 + c, a + b + c*10))
    

if  __name__=='__main__':
    main()

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

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

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

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

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

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

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

l.sort()

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

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

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

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

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

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

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

ret = a+b+c-m+10*m

  
print(ret)

Solution (Python):

import sys










def main():
    nums = sys.stdin.readline().split()
    nums.sort(reverse=True)
    ans = int(''.join(nums[:2])) + int(nums[2])
    print(ans)

if __name__ == "__main__":
    main()

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

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

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

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

Solution (Python):
from sys import stdin
import fractions

li = list(map(int,stdin.readline().rstrip().split()))
li.sort()
print(li[-1]*10+li[-2]+li[-3])

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

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

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

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

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

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

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

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

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

Solution (Python):

a, b, c = [int(s) for s in input().split()]
print(max(a * 10 + b + c, a + b * 10 + c, a + b + c * 10))

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

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

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

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

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

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

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

list_ = [a,b,c]
list_ = sorted(list_)

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

Solution (Python):

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

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

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

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

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

Solution (Python):
A,B,C = map(str,input().split())
box = [A,B,C]
box.sort(reverse = True)

tasu = int(box[0]+box[1])
nokori = int(box[2])

ans = tasu + nokori
print(ans)
"""
print(tasu)
print(type(tasu))
"""

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]
a,b,c=map(int,input().split())
print(max(a,b,c)*9+a+b+c)

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

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

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

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

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 + a + b)

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

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

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

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

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

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

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

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

c1 = 0

for i2 in range(2):
    if n1[i2 + 1] > n1[c1]:
        c1 = i2 + 1

r1 = 0
for i1 in range(3):
    if c1 == i1:
        r1 += n1[i1] * 10
    else:
        r1 += n1[i1]

print(r1)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

N.sort()

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

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

num_list.sort()

L = num_list[2]
M = num_list[1]
S = num_list[0]

print(L * 10 + M + S)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
def main():
    inputs = [int(s) for s in input().split()]
    sorted_list = sorted(inputs,reverse=True)
    result = int(str(sorted_list[0])+str(sorted_list[1])) + sorted_list[2]
    print(result)

if __name__ == "__main__":
    main()

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

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

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

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

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

Solution (Python):
'''A - Maximize the Formula
https://atcoder.jp/contests/abc110/tasks/abc110_a

>>> main([1, 5, 2])
53
>>> main([9, 9, 9])
108
>>> main([6, 6, 7])
82'''


def main(i):
    _i = sorted(i, reverse=True)
    head = str(_i[0]) + str(_i[1])

    print(int(head) + _i[2])


if __name__ == '__main__':
    i = [i for i in map(int, input().split(' '))]
    main(i)

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

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

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())
AB_C = A*10+B+C
A_BC = A+B*10+C
A_CB = A+C*10+B
B_AC = B+A*10+C
B_CA = B+C*10+A
C_BA = C+B*10+A
max = 0
S = []
S.append(AB_C)
S.append(A_BC)
S.append(A_CB)
S.append(B_AC)
S.append(B_CA)
S.append(C_BA)
for i in range(len(S)):
    if S[i] > max:
        max = S[i]
print(max)

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

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

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

Solution (Python):
import os, sys, re, math

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

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

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

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

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

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

Solution (Python):
import os, sys, re, math

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

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

Solution (Python):
line = raw_input()
abc = [int(s) for s in line.split(' ')]
abc.sort()

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

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

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

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

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

Solution (Python):
n = input().split()
n.sort(reverse=True)
a, b, c = n
print(int(a+b) + int(c))

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

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    a, b, c = sorted(input().split(), reverse=True)
    print(int(a + b) + int(c))


if __name__ == "__main__":
    main()

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

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

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

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

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    abc = list(map(int, input().rstrip('\n').split()))
    abc.sort(reverse=True)
    print(abc[0] * 10 + abc[1] + abc[2])


if __name__ == '__main__':
    slove()

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

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

data_sort = sorted(data, reverse=True)

tmp = int(str(data_sort[0])+str(data_sort[1]))
result = tmp + data_sort[2]
print(result)

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

Solution (Python):
a=list(map(int,input().split()))
M=max(a)
ans=0
for x in a:
    ans+=x

print(M*9+ans)

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

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

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

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

total=0
for i in A:
    total +=i

print(max(A)*9+total)

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

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

s1 = a*10 + b + c
s2 = b*10 + a + c
s3 = c*10 + a + b

print(max(s1,s2,s3))

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

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

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

na = lambda : map(int, stdin.readline().split())

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

Solution (Python):

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

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(5 * 10**5)
input = sys.stdin.readline

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

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

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