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

max_num = []

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

print(max(max_num))

Solution (Python):
a, b, c =  [ int(v) for v in 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())
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[2]*10+abc[1]+abc[0])

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

Solution (Python):
A,B,C = map(int,input().split())
D = [A,B,C]
X = max(D)
Z = min(D)
Y = sum(D) - (X + Z)
E = str(X) + str(Y)
print(int(E) + int(Z))

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

Solution (Python):
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    a = f()
    a = sorted(a, reverse = True)
    print(10*a[0] + a[1] + a[2])

solve()

Solution (Python):
c = [int(i) for i in input().split(' ')]
c.sort(reverse=True)

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

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

Solution (Python):
from sys import stdin

N = [int(x) for x in stdin.readline().rstrip().split()]
N.sort(reverse=True)
print(N[0] * 10 + N[1] + N[2])

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

m=max(a,b,c)

print(int(9*m+a+b+c))

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

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

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

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

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(input().split())
n = sorted(n, reverse=True)

ans = int(''.join(n[:2])) + int(n[2])

print(ans)

Solution (Python):

import sys


def solve(A: int, B: int, C: int):

    L = [A,B,C]
    L.sort(reverse=True)
    L[0] *= 10
    print(sum(L))

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

print(ans)

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

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

Solution (Python):
from sys import stdin
l = [int(x) for x in sorted(stdin.readline().rstrip().split(), reverse=True)]
print(int(str(l[0]) + str(l[1])) + l[2])

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

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

if __name__ == "__main__":
    main()

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

Solution (Python):
s=input().split()
ss=sorted(s)
print(int(ss[-1])*10+int(ss[0])+int(ss[1]))

Solution (Python):
if __name__ == '__main__':
    input_list = sorted(map(int, input().split()), reverse=True)

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

Solution (Python):
a = list(input().split())
b = int(max(a))
a.remove(max(a))
result = 0
for i in range(2):
    result += int(a[i])
print(b * 10 + int(result))

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

L = [int(v) for v in input().split()]
L.sort(reverse = True)

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

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

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

Solution (Python):
lst = input().split()
lst_s = sorted(lst)


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

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

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

Solution (Python):

"""
Created on Sun May 19 14:58:31 2019

@author: Yamazaki Kenichi
"""

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

A.sort()

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

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):
def main():
    ABC = list(map(int, input().split()))
    A,B,C = ABC[0], ABC[1], ABC[2]
    arr = [A*10+B+C, A+B*10+C, A+B+C*10]
    print(max(arr))
main()

Solution (Python):

"""
A - Maximize the Formula
https://atcoder.jp/contests/abc110/tasks/abc110_a

"""
import sys


def solve(nums):
    return nums[0]*10 + nums[1] + nums[2]


def main(args):
    nums = sorted(map(int, input().split()), reverse=True)
    ans = solve(nums)
    print(ans)


if __name__ == '__main__':
    main(sys.argv[1:])

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

Solution (Python):
a,b,c=sorted(input().split())
print(eval("{}{}+{}".format(c,b,a)))

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

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

Solution (Python):

l = input().split()
l.sort(reverse=True)
Y = int(l[-1])
l.pop()
X = int(''.join(l))
print(X + Y)

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

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

ans = sorted(s)

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

Solution (Python):
s = input().split()
s.sort(reverse=True)
print(int(''.join(s[:2]))+int(s[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 sys


def input():
    return sys.stdin.readline()[:-1]








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

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

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

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

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

n=sorted(n, reverse=True)

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

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

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

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

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=map(int,input().split())
print(9*max(A,B,C)+A+B+C)

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

a = max(lst)
lst.remove(a)
b = max(lst)
lst.remove(b)
ans = str(a) + str(b)
ans = int(ans) + int(lst[0])
print(ans)

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

i = L.index(max(L))

sum = L.pop(i) * 10

for j in L : 
    sum += j
    
print(sum)

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

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

ABC.sort()
print(sum(ABC[:2]) + 10*ABC[2])

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

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

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

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

Solution (Python):
[a,b,c] = [int(j) for j in input().split()]
[u,v,w] = [max([a,b,c]),a+b+c-max([a,b,c])-min([a,b,c]),min([a,b,c])]
print(10 * u + v + w)

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

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

Solution (Python):
A=[int(i) for i in input().split()]
B=[]
B.append(A[0]*10+A[1]+A[2])
B.append(A[0]+A[1]*10+A[2])
B.append(A[0]+A[1]+A[2]*10)
print(max(B))

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

num.sort(reverse=True)

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

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

Solution (Python):

from sys import stdin

ABC = list(map(int,stdin.readline().rstrip().split()))

def main():
    print(ABC.pop(ABC.index(max(ABC))) * 10 + sum(ABC))
    
if __name__ == '__main__':
    main()

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

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

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

maxa=max(A,B,C)

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

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

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

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

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

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

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

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

Solution (Python):


from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy

def intin():
    input_tuple = input().split()
    if len(input_tuple) <= 1:
        return int(input_tuple[0])
    return tuple(map(int, input_tuple))


def intina():
    return [int(i) for i in input().split()]


def intinl(count):
    return [intin() for _ in range(count)]


def modadd(x, y):
    global mod
    return (x + y) % mod


def modmlt(x, y):
    global mod
    return (x * y) % mod


def lcm(x, y):
    while y != 0:
        z = x % y
        x = y
        y = z
    return x


def get_divisors(x):
    retlist = []
    for i in range(1, int(x**0.5) + 3):
        if x % i == 0:
            retlist.append(i)
            retlist.append(x // i)
    return retlist


def make_linklist(xylist):
    linklist = {}
    for a, b in xylist:
        linklist.setdefault(a, [])
        linklist.setdefault(b, [])
        linklist[a].append(b)
        linklist[b].append(a)
    return linklist


def calc_longest_distance(linklist, v=1):
    distance_list = {}
    distance_count = 0
    distance = 0
    vlist_previous = []
    vlist = [v]
    nodecount = len(linklist)

    while distance_count < nodecount:
        vlist_next = []
        for v in vlist:
            distance_list[v] = distance
            distance_count += 1
            vlist_next.extend(linklist[v])
        distance += 1
        vlist_to_del = vlist_previous
        vlist_previous = vlist
        vlist = list(set(vlist_next) - set(vlist_to_del))

    max_distance = -1
    max_v = None
    for v, distance in distance_list.items():
        if distance > max_distance:
            max_distance = distance
            max_v = v

    return (max_distance, max_v)


def calc_tree_diameter(linklist, v=1):
    _, u = calc_longest_distance(linklist, v)
    distance, _ = calc_longest_distance(linklist, u)
    return distance





def main():
    a, b, c = intin()

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

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


if __name__ == '__main__':
    main()

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

print(10 * c+b+a)

Solution (Python):
abc="".join(sorted(input().split(" "))[::-1])
print(int(abc[:2])+int(abc[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,input().split())
ans = 9*max(a,b,c)+(a+b+c)
print(ans)

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

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

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

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

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

Solution (Python):
a, b, c = 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())
list = [a,b,c]
list1 = sorted(list)
d = str(list1[-1]) + str(list1[-2])
num = int(d) + list1[0]
print(num)

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

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

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

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

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

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

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

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

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

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

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

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

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

a = sorted(a)

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

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

print(10 * C + B + A)

Solution (Python):


ls = [int(c) for c in input().split()]
ls.sort()
ans = ls[2] * 10 + ls[1] + ls[0]
print(ans)

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

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

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

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

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

Solution (Python):

import sys
from math import *
from itertools import *
from collections import *
from functools import *
try:
    from math import gcd
except Exception:
    from fractions import gcd


def solve(A: int, B: int, C: int):
    a, b, c = sorted([A, B, C])
    return a + b + 10 * c


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))  
    result = solve(A, B, C)
    print(result)

if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):
a, b, c = map(int, input().split())
ABC = [a, b, c]
big = max(ABC)
small = min(ABC)
mid = sum(ABC) - big - small
print(big * 10 + mid + small)

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

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

X = sorted(X)
print(X[2]*10 + X[1] + X[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 = sorted(input().split(), reverse=True)
print(int(a+b) + int(c))

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

Solution (Python):
a = sorted(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(a[0]*10+a[1]+a[2])

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

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

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

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

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

Solution (Python):

import re

n = input()
n = re.split(" ",n)

n.sort()
n.reverse()

A = int(n[0])
B = int(n[1])
C = int(n[2])

print(10*A + B + C)

Solution (Python):
import bisect
from collections import Counter
def MI(): return map(int, input().split())
def II(): return int(input())
def IS(): return input()
def LI(): return list(map(int, input().split()))

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

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

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

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

Solution (Python):


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

result = 10 * input_data[0] + input_data[1] + input_data[2]
print(result)

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

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

N.sort(reverse=True)

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

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

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

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

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

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

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

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

Solution (Python):
Cards = [int(x) for x in 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(B+C)+int(A),
        int(C+B)+int(A),
        int(C+A)+int(B),
        int(A+C)+int(B)]))

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

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

Solution (Python):
l = list(input().split())
l.sort()
ans = int(l[-1] + l[-2]) + int(l[-3])
print(ans)

Solution (Python):
import functools
import math

import os

INF = float('inf')


def inp():
    return int(input())


def inpf():
    return float(input())


def inps():
    return input()


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


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


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


def debug(fn):
    if not os.getenv('LOCAL'):
        return fn

    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        print('DEBUG: {}({}) -> '.format(
            fn.__name__,
            ', '.join(
                list(map(str, args)) +
                ['{}={}'.format(k, str(v)) for k, v in kwargs.items()]
            )
        ), end='')
        ret = fn(*args, **kwargs)
        print(ret)
        return ret

    return wrapper


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

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

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

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

if nlist.count(a) == 3:
    a = str(a)
    fst = a + a
    print(int(fst) + int(a))
else:
    maxn = max(nlist)
    minn = min(nlist)

    if nlist.count(maxn) > 1:
        maxn = str(maxn)
        fst = maxn + maxn
        print(int(fst) + minn)
    elif nlist.count(minn) > 1:
        minn = str(minn)
        maxn = str(maxn)
        fst = maxn + minn
        print(int(fst) + int(minn))
    else:
       nlist.pop(nlist.index(maxn))
       nlist.pop(nlist.index(minn))
       fst = str(maxn) + str(nlist[0])
       print(int(fst) + minn)

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 = list(input().split())
ABC.sort(reverse=True)
print(int(ABC[0] + ABC[1]) + int(ABC[2]))

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

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

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

Solution (Python):

data = sorted(list(map(int, input().rstrip().split())))

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

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

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

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

Solution (Python):

def main():
    a = list(map(int, input().split()))
    if a[0] == max(a):
        print((a[0] * 10 + a[1] + a[2]))
    elif a[1] == max(a):
        print((a[1] * 10 + a[0] + a[2]))
    else:
        print((a[2] * 10 + a[1] + a[0]))


if __name__ == '__main__':
    main()

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] = LS()
    return l
sys.setrecursionlimit(1000000)
mod = 1000000007


def A():
    a,b,c = LI()
    print(9*max(a,b,c)+a+b+c)
    return


def B():
    return


def C():
    return


def D():
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


def I_():
    return


def J():
    return


if __name__ == "__main__":
    A()

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

list = [a,b,c]
max_fig = max(list)
max_result = max_fig*10 + sum(list) - max_fig

print(max_result)

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

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

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

Solution (Python):

import sys


def solve(A: int, B: int, C: int):
    a = sorted([A, B, C])
    print(a[2]*10+a[1]+a[0])
    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):
a,b,c=map(int,input().split())
d=a*10 +b+c
e=b*10 +a+c
f=c*10 +a+b
print(max(d,e,f))

Solution (Python):


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

a.sort()

b, c, d = a

print(d * 10 + c + b)

Solution (Python):
abc = list(map(int, 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):

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

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

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

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

print(a*10 + b + c)

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

if a>=b and a>=c :
    print(int(str(a)+str(b))+int(c))
elif b>=a and b>=c :
    print(int(str(b)+str(a))+int(c))
elif c>=a and c>=b :
    print(int(str(c)+str(a))+int(b))
else:
    pass

Solution (Python):

import sys
import copy
import collections
from bisect import bisect_left

def main():
	A, B, C = map(int, input().split(" "))
	
	ans = 0;
	aa = max(A, B, C)
	ans += aa * 10
	
	print(ans + A + B + C - max(A, B, C))
		
	
if __name__ == "__main__":
	main()

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

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

if B < C:
    tmp = B
    B = C
    C = tmp
if A < B:
    tmp = A
    A = B
    B = tmp
print((A * 10) + B + C)

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

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

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

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

Solution (Python):



import math

a = list(map(int, input().split()))
a = sorted(a, key=lambda x: -x)
print(a[0]*10 + sum(a[1:]))

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

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

A = sorted(A)
B = str(A[2]) + str(A[1])
B = int(B)
print(B+A[0])

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

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

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

Solution (Python):
a,b,c = map(int,input().split())
num = []
num.append(a)
num.append(b)
num.append(c)
ookii = num.copy()
ooi = max(ookii)
num.remove(max(num))
print(ooi * 10 + num[0] + num[1])

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

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

Solution (Python):
A, B, C = sorted(input().split(), reverse=True)
print(eval(A+B+"+"+C))

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

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

ABC = sorted(ABC, reverse=True)

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

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

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

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

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

Solution (Python):


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

if __name__ == '__main__':
    main()

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

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