Problem:
 Score : 100 points    Problem Statement Snuke is buying a bicycle.
The bicycle of his choice does not come with a bell, so he has to buy one separately.  He has very high awareness of safety, and decides to buy two bells, one for each hand.  The store sells three kinds of bells for the price of a , b and c yen (the currency of Japan), respectively.
Find the minimum total price of two different bells.      Constraints  1 \leq a,b,c \leq 10000  a , b and c are integers.         Input Input is given from Standard Input in the following format:  a  b  c       Output Print the minimum total price of two different bells.        Sample Input 1 700 600 780      Sample Output 1 1300   Buying a 700 -yen bell and a 600 -yen bell costs 1300 yen.  Buying a 700 -yen bell and a 780 -yen bell costs 1480 yen.  Buying a 600 -yen bell and a 780 -yen bell costs 1380 yen.   The minimum among these is 1300 yen.       Sample Input 2 10000 10000 10000      Sample Output 2 20000  Buying any two bells costs 20000 yen.

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

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

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

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

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

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

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

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

Solution (Python):

import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)

a, b, c = map(int,readline().split())
print(min(a + b, b + c, c + a))

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

ans = sum(X) - max(X)

print(ans)

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

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

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

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

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

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

a_b = a + b
a_c = a + c
b_c = b + c

min_ = a_b
if a_c < min_:
    min_ = a_c
if b_c < min_:
    min_ = b_c

print(min_)

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

Solution (Python):

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

Solution (Python):


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

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

print(list_[0] + list_[1])

Solution (Python):
import itertools
def main():
  s = list(map(int,input().split()))
 
  ans = float("inf")

  for m in itertools.combinations(s,2):
    ans = min(ans,sum(m))
  print(ans)
if __name__ == '__main__':
  main()

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

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

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

Solution (Python):

a,b,c = map(int,input().split())
if (a == b)&(b == c):
    print(a + b)
elif(a > b)&(a > c):
    print(b + c)
elif (b > a)&(b > c):
    print(a + c)
elif (c > a)&(c > b):
    print(a + b)

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

if a >= b and a >= c:
	answer = b + c
elif b >= a and b >= c:
	answer = a + c
elif c >= a and c >= b:
	answer = a + b

print(answer)

Solution (Python):

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

print(min(a+b,b+c,c+a))

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

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

print(a+b)

Solution (Python):
import sys

*c, = map(int, sys.stdin.readline().split())
c.sort()

def main():
    print(c[0] + c[1])

if __name__ ==  '__main__':
    main()

Solution (Python):

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

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

beru.sort()
print(beru[0]+beru[1])

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

print(line[0] + line[1])

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

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

Solution (Python):
if __name__ == '__main__':
    a = [int(i) for i in input().split()]
    a.sort()

    print(a[0]+a[1])

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

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

t.sort()

print(t[0]+t[1])

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

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

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

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

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

Solution (Python):
import math

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

print(a+b)

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

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

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

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

print(min(a+b,b+c,c+a))

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

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

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

Solution (Python):
s=list(map(int,input().split()))
print(sum(sorted(s)[:2]))

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

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

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

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

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

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

Solution (Python):
import itertools
m = list(map(int,input().split()))
l = [sum(t) for t in list(itertools.combinations(m, 2))]
print(min(l))

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

print(min(price)+sorted(price)[-2])

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

Solution (Python):
abc = list(map(int, input().split()))
print(sum(sorted(abc)[:2]))

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

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

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

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

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

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

Solution (Python):
import math

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

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

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

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

Solution (Python):


from itertools import combinations


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


combi_list = list(combinations(['A', 'B', 'C'], 2))
min_cost = 30000


for combi in combi_list:
    tmp = 0
    if combi[0]=='A':
        tmp += a
    elif combi[0]=='B':
        tmp += b
    else:
        tmp += c

    if combi[1]=='A':
        tmp += a
    elif combi[1]=='B':
        tmp += b
    else:
        tmp += c

    min_cost = min(min_cost, tmp)


print(min_cost)

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

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

del bells[bells.index(max(bells))]

print(sum(bells))

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

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

list.sort()

print(list[0]+list[1])

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

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

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

print(min(a+b,a+c,b+c))

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

print(sum(A) - max(A))

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

a.sort()

print(a[0]+a[1])

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

Solution (Python):
t = [int(x) for x in input().split(' ')]
t.sort()
print(t[0]+t[1])

Solution (Python):
l= list(map(int, input().split()))
ans = sum(l) - max(l)
print(ans)

Solution (Python):
abc = [int(i) for i in input().split()]
abc.sort()
print(sum(abc[:2]))

Solution (Python):
a, b, c = map(int, raw_input() .split())
d = a + b
e = b + c
f = a + c
print min(d, e, f)

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

Solution (Python):

import sys


def solve(a: int, b: int, c: int):
    print(a + b + c - max(a, b, 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))  
    solve(a, b, c)


if __name__ == '__main__':
    main()

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

print(sum(a) - max(a))

Solution (Python):

bell=list(map(int,input().split()))
print(sum(bell)-max(bell))

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

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

print(a[0]+a[1])

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

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

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

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

Solution (Python):

a,b,c=list(map(int,input().split()))
print(sum([a,b,c])-max([a,b,c]))

Solution (Python):
a,b,c=map(int,input().split())
numbers=[]
numbers.append(a)
numbers.append(b)
numbers.append(c)
numbers.remove(max(numbers))
print(sum(numbers))

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

Solution (Python):
p=list(map(int,input().split()))
print(sum(p)-max(p))

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

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

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

Solution (Python):
a,b,c = map(int, input().split())
min_bell = 100000
if a + b < min_bell:
  min_bell = a + b
if a + c < min_bell:
  min_bell = a + c
if c + b < min_bell:
  min_bell = c + b
print(min_bell)

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

print(a+b)

Solution (Python):









import sys



ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)

def main():
    a, b, c = list(map(int,ipti().split()))
    print(a+b+c-max(a,b,c))

if __name__ == '__main__':
    main()

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

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

Solution (Python):


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

print(sum(l)-max(l))

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

print(min(a+b,b+c,a+c))

Solution (Python):
a = sorted([int(x) for x in input().split()])
print(sum(a[:2]))

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

max =max(a,b,c)

print(a+b+c-max)

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

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    mod=10**9+7
    a,b,c=MI()
    print(a+b+c-max(a,b,c))

main()

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

Solution (Python):
def main():
    import sys
    
    sys.setrecursionlimit(10000000)
    from collections import Counter, deque
    
    from itertools import combinations, permutations
    
    from bisect import bisect_left,bisect_right
    from math import floor, ceil
    

    

    a,b,c = map(int, input().split())
    print(min(a+b,a+c, b+c))
if __name__ == '__main__':
    main()

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

Solution (Python):
prices = list(map(int, input().split()))
prices.sort()
print(sum(prices[0:2]))

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

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

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

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

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

Solution (Python):

a=list(map(int,input().split()))
print(sum(a)-max(a))

Solution (Python):


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

sum_abc = a+b+c

ans=10000*2
for i in [a,b,c]:
    ans = min(ans, (sum_abc - i))

print(ans)

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
print(sum(sorted(map(int, input().split()))[0:2]))

Solution (Python):
def main():
    bell_prices = sorted(list(map(int, input().split())))
    print(sum(bell_prices[:2]))


if __name__ == '__main__':
    main()

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

print(min(a + b, b + c, c + a))

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

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

print(a[0]+a[1])

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

Solution (Python):
S,M,L=sorted(list(map(int,input().split())))
print(S+M)

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

print(min(a + b, b + c, c + a))

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

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

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

ans = sum(abc) - max(abc)
print(ans)

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

print(sum(sorted(l)[:2]))

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

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

print(lst1[0]+lst1[1])

Solution (Python):
p = sorted(list(map(int, input().split())))
print(sum(p[:2]))

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

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

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

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

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

Solution (Python):


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

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

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

Solution (Python):
import sys
 
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda x: [na() for _ in range(x)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda x: [ns() for _ in range(x)]
nas = lambda: stdin.readline().split()

a = na()
a.sort()
print(a[0] + a[1])

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

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

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

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

print(a[0]+a[1])

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

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

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

print(min(a+b,b+c,a+c))

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

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

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

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

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

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

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

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

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

l=[a,b,c]
l.sort()
print(l[0]+l[1])

Solution (Python):
def miner(a):
    
    a.sort()
    ans = int(a[0]) + int(a[1])
    return ans

def main():
    a = list(map(int , input().split()))
    print(miner(a))

if __name__ == '__main__':
    main()

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

Solution (Python):
a, b, c = list(map(int, input().split()))
m = [a, b, c]
maxvalue = 0
for i in range(len(m)):
    if m[i] > maxvalue:
        maxvalue = m[i]
print(a+b+c-maxvalue)

Solution (Python):
a,b,c=map(int,input().split())
ab = a+b
ac = a+c
bc = b+c

ans = min(ab,ac,bc)
print(ans)

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

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

Solution (Python):
a,b,c=[int(s) for s in input().split()]
print(min([a+b,b+c,c+a]))

Solution (Python):

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



ans = min(a+b, b+c, c+a)
print(ans)

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

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

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

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

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

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

min = l[0]

for i in l:
    if min > i:
        min = i

print(min)

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

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

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

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

Solution (Python):




def main():
    A, B, C = map(int, input().split())
    print(sum(sorted([A, B, C])[:2]))


if __name__ == "__main__":
    main()

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

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

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

List = [a+b, b+c, c+a]
List.sort()

print(List[0])

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

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

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

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

Solution (Python):
"""
author : halo2halo
date : 29, Jan, 2020
"""

import sys
import itertools



read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

a = [int(i) for i in readline().split()]
a.sort()
print(sum(a[:2]))

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

Solution (Python):
S=sorted(list(map(int,input().split())))
print(sum(S[:2]))

Solution (Python):
p,q,r=map(int,input().split())
print(p+q+r-max([p,q,r]))

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

Solution (Python):

a = list(map(int,input().split()))
print(sum(a)-max(a))

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

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

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

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

ans = a + b + c - max(a, b, c)

print(ans)

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

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

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

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 accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce

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

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

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

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

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

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

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

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

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

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

Solution (Python):
a,b,c=map(int,input().split())
answer = float('inf')
if a+b<=answer:
    answer=a+b
if c+b<=answer:
    answer=c+b
if a+c<=answer:
    answer=a+c
print(answer)

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

print(sum(sorted(l)[:2]))

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

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

lists = [a,b,c]

lists = sorted(lists)

print(lists[0]+lists[1])

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

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

Solution (Python):
import sys
input = sys.stdin.readline
li = [int(i) for i in input().split()]
li.sort()
print(li[0] + li[1])

Solution (Python):
x = sorted(list(map(int, input().split())))
print(sum(x[:2]))

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

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

print(min(a+b, b+c, c+a))

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

print(a+b)

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

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

print(int(r))

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

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

a=list(map(int,input().split()))
a.sort()
print(a[0]+a[1])

Solution (Python):
num = input().split()
num_i = [int(s) for s in num]

a,b,c = num_i
min_1 = a+b
min_2 = b+c
min_3 = c+a

min_a1 = min(min_1, min_2)
min_a = min(min_a1, min_3)
print(min_a)

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

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

Solution (Python):


import numpy as np
import fractions as fra

a=[int(x) for x in input().split()]
a=sorted(a)

print(a[0]+a[1])

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

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

ans = min(a+b, b+c)
ans = min(ans, a+c)

print(ans)

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

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

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

print(pArray[0]+pArray[1])

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

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

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

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

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

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

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

Solution (Python):
a, b, c = map(int, input().split())
ab=a+b
ac=a+c
bc=b+c

if ab < ac and ab < bc:
    print(ab)
elif ac < ab and ac < bc:
    print(ac)
elif bc < ab and bc < ac:
    print(bc)
else:
    print(ab)

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

Solution (Python):
import sys
input = sys.stdin.readline
a = [int(x) for x in input().split()]
a.sort()
print(a[0] + a[1])

Solution (Python):
a,b,c=map(int,input().split())
ans=min({a+b,a+c,b+c,})
print(ans)

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

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

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

print(A[0]+A[1])

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

print(lis[0] + lis[1])

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

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

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

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

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

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

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

print(x[0] + x[1])

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

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

x = sorted([a, b, c])
print(x[0] + x[1])

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

Solution (Python):
import math
import queue
import bisect
import heapq
import time
import itertools

mod = int(1e9+7)

def swap(a,b):
    return (b,a)

def gcd(a,b): 
    if (a<b):
        a,b = swap(a,b)
    if (b==0):
        return a
    else:
        return gcd(b,a%b)

def lcm(a,b): 
    return a/gcd(a,b)*b

def divisors(a): 
    divisors = []
    for i in range(1,int(a**0.5)+1):
        if a%i==0:
            divisors.append(i)
            if i!=a//i:
                divisors.append(a//i)
    return divisors

def is_prime(a): 
    if a<2:
        return False
    elif a==2:
        return True
    elif a%2==0:
        return False
    sqrt_num = int(a**0.5)
    for i in range(3,sqrt_num+1,2):
        if a%i==0:
            return False
    return True

def prime_num(a): 
    pn = [2]
    for i in range(3,int(a**0.5),2):
        prime = True
        for j in pn:
            if i%j==0:
                prime = False
                break
        if prime:
            pn.append(i)
    return pn

def prime_fact(a): 
    sqrt = math.sqrt(a)
    res = []
    i = 2
    if is_prime(a):
        res.append(a)
    else:
        while a!=1:
            while a%i==0:
                res.append(i)
                a //= i
            i += 1
    return res

def main():
    a = [x for x in map(int,input().split())]
    a.sort()
    print(a[0]+a[1])
    return

if __name__=='__main__':
    main()

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

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

print(min(a+b, a+c, b+c))

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

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

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

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

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

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

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

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

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

A.sort()
print(A[0] + A[1])

Solution (Python):
abc = list(map(int, input().split()))
x = max(abc)
abc.remove(x)
print(sum(abc))

Solution (Python):
import sys

*p, = map(int, sys.stdin.readline().split())

def main():
    p.sort()
    return sum(p[:2])

if __name__ == '__main__':
    ans = main()
    print(ans)

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

Solution (Python):
import math

a = [int(i) for i in input().split()]
print(sum(a) - max(a))

Solution (Python):
import math

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

Solution (Python):
al = list(map(int,input().split()))
al = sorted(al)
print(sum(al[:2]))

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

Solution (Python):
import math

a = sorted(list(map(int, input().split())))
print(a[0] + a[1])

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

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

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

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

Solution (Python):
import sys

a, b, c = map(int, sys.stdin.readline().split())

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

print(a + b + c - m)

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

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

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

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