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):
L = sorted(map(int, input().split()))
print (sum(L[0:2]))

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

s = [a+b , b+c , a+c]
ans = 999999
for i in s:
    ans = min(i , ans)
print(ans)

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

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

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

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

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

Solution (Python):

import sys
INF = float("inf")


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

Solution (Python):
c = list(map(int, input().split(' ')))
print(sum(sorted(c)[:-1]))

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

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

Solution (Python):

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

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

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

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

Solution (Python):

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

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

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

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

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

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

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

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()))
a.sort()
print(sum(a[:2]))

Solution (Python):


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

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

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

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

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

cost.sort()
print(sum(cost[:2]))

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

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

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

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

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

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

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

print(sum(a[1:]))

Solution (Python):
a, b, c = list(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, 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, c+a))

Solution (Python):

import sys
import copy
import collections
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import math
import itertools
 




 
def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
 
def main():
    a,b,c = inputMap()
    
    tmp = []
    tmp.append(a)
    tmp.append(b)
    tmp.append(c)
    tmp.sort()
    
    print(tmp[0] + tmp[1])
        
if __name__ == "__main__":
	main()

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

Solution (Python):
from itertools import combinations
a,b,c = map(int, input().split())
ans = float("INF")
for i in combinations([a,b,c],2):
    ans = min(ans, sum(i))
print(ans)

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

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

t.remove(max(t))

print(sum(t))

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

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(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 = 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(sum((a,b,c)) - max(a, b, c))

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

Solution (Python):

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

if (a + b) <= (b + c) and (a + b) <=(c + a):
    print(a + b)
elif(b + c) <= (a + b) and (b + c)<= (c + a):
    print(b +c)
elif(c + a) <= (a + b) and (c + a) <= (b + c):
    print(c + a)

Solution (Python):
kane = list(map(int, input().split()))
kane.sort()
print(kane[0] + kane[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(a+b, b+c, c+a))

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):
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())
ans = [a, b, c]
ans = sorted(ans)
print(ans[0] + ans[1])

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

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

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

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

d = max(a, b, c)

print(a + b + c - d)

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

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

Solution (Python):
import sys, re, os
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
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

l = LIST()
comb = list(combinations(l, 2))
m_l = []
for c in comb:
    m_l.append(sum(c))

ans = min(m_l)
print(ans)

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

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

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

Solution (Python):

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


def A():
    a, b, c = LI()
    print(min(a+b,b+c,c+a))
    return


def B():
    return


def C():
    return


def D():
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == '__main__':
    A()

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

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

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

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

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


main()

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):
a=map(int,input().split())
print(sum(sorted(a)[0:2]))

Solution (Python):

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

Solution (Python):

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




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

Solution (Python):
a,b,c=(int(i) for i in 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):
a, b, c = map(int, input().split())

expensive = max([a, b, c])
print(sum([a, b, c]) - expensive)

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

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

print(sum(nums[0:2:]))

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

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

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

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

Solution (Python):


def main():
    data = list(map(int, input().split()))
    print(sum(data) - max(data))



if __name__ == '__main__':
    main()

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(s[0]+s[1])

Solution (Python):



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

abc_list.sort()





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

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

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

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

a, b, c = nl()

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

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

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

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

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

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

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

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

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

Solution (Python):

import sys
sys.setrecursionlimit(300000)


def solve(a: int, b: int, c: int):
    ret = sum([a,b,c]) - max([a,b,c])
    print(ret)
    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())
print(sum([a,b,c])-max(a,b,c))

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

Solution (Python):
a = list(map(int,input().split()))
print(sum(a)-max(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, c+a))

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

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

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


abc()

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

Solution (Python):
c = list(map(int, input().split()))
print(sum(c)-max(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())
print(min(a+b,b+c,c+a))

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

Solution (Python):

value = list(map(int, input().split()))
value.sort()
print('{}'.format(value[0] + value[1]))

Solution (Python):
def main():
    a, b, c = [int(ele) for ele in input().split()]
    ab = a + b
    bc = b + c
    ca = c + a
    ans = min([ab, bc, ca])
    print(ans)


if __name__ == "__main__":
    main()

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

Solution (Python):
a, b, c = (int(i) for i in input().split())

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

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

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

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

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

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

Solution (Python):


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

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

Solution (Python):
a = sorted(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,b,c =list(map(int,input().split(" ")))
print((a+b+c)-max(a,b,c))

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

li.sort()

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

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

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

Solution (Python):
def resolve():
    ls = []

    for s in map(int, input().split(' ')):
        ls.append(s)

    ls.sort()
    print(ls[0] + ls[1])
    pass


if __name__ == '__main__':
    resolve()

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

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

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

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

ans1 = a+b
ans2 = a+c
ans3 = c+b

print(min(ans1,ans2,ans3))

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

ans1 = a+b
ans2 = a+c
ans3 = c+b

print(min(ans1,ans2,ans3))

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

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

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

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

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

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

Solution (Python):
z = map(int,input().split())
z = sorted(z)
print(z[0] + z[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, b+c, c+a))

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

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

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

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

Solution (Python):
s = list(map(int,input().split()))
m = min(s)
s.remove(m)
print(m+min(s))

Solution (Python):
list_num = [int(num) for num in input().split()]
list_num.sort(reverse=False)

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

Solution (Python):
import itertools

a, b, c = map(int, input().split())
print(min(map(sum, itertools.combinations((a, b, c), 2))))

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

bell=sorted(bell,reverse=True)

print(bell[1]+bell[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):
S = sorted(list(map(int,input().split(' '))))
print(S[0] + S[1])

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

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

Solution (Python):
a, b, c = map(int, raw_input().split())
s = a + b
x = b + c
y = a + c
min = a + b + c
if s > x:
    min = x
else:
    min = s
if min > y:
    min = y
print min

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

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

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

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

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

Solution (Python):
a,b,_=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):
nums = sorted(list(map(int, input().split())))
print(nums[0]+nums[1])

Solution (Python):
a=[int(i) for i in 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):
abc = list(map(int, input().split()))

abc.sort()

print(sum(abc[:2]))

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

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

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

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

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

Solution (Python):
import sys


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








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

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

Solution (Python):

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

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

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

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

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

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()))
ans = sum(a)-max(a)
print(ans)

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

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):
print(sum(sorted(list(map(int,input().split())))[:2]))

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

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

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

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

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

print(m)

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

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

print(m)

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

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

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

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

Solution (Python):

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

    return a, b, c


def submit():
    a, b, c = read_input()

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

if __name__ == '__main__':
    submit()

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

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

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math


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

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

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

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

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

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

solve()

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

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

Solution (Python):
l = list(map(int,input().split()))
ans = 0
for i in l:
    ans += i
print(ans - max(l))

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

Solution (Python):


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

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

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

a = sorted(a)

print(sum(a[0:2]))

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

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

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

Solution (Python):
import functools

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 inpm(line):
    return [inp() for _ in range(line)]


def inpfm(line):
    return [inpf() for _ in range(line)]


def inpsm(line):
    return [inps() for _ in range(line)]


def inlm(line):
    return [inl() for _ in range(line)]


def inlfm(line):
    return [inlf() for _ in range(line)]


def inlsm(line):
    return [inls() for _ in range(line)]


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 = inl()
a.sort()
print(a[0] + a[1])

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

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

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

Solution (Python):

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

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

print(min(a+b,b+c,a+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):
p = sorted([int(n) for n in input().split()])

print(sum(p[:2]))

Solution (Python):
from functools import reduce
import math

def main():
    
    
    
    

    
    
    
    
    
    
    
    
    
    
    
    
    
    INF = float("inf")
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

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

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

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

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

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

ans = 0
ans += min(a)
a.pop(a.index(ans))
ans += min(a)
print(ans)

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

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

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

Solution (Python):
A=[int(i) for i in input().split()]
print(sum(A)-max(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())
arr=[a,b,c]
arr=sorted(arr)
print(arr[0]+arr[1])

Solution (Python):
a = sorted([int(item) for item in input().split()])
print(sum(a[:-1]))

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

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

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

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

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

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

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

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

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

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

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

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()))
print(sum(x)-max(x))

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

abc = sorted(abc)

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

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

x.sort()

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

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

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

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

Solution (Python):

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

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

Solution (Python):
from itertools import combinations


def main():
    a, b, c = map(lambda n: int(n), input().split())
    result = map(lambda p: p[0] + p[1], combinations((a, b, c), r=2))
    print(min(result))


if __name__ == '__main__':
    main()

Solution (Python):
import sys

def main():
    input = sys.stdin.readline
    A = list(map(int, input().split()))
    A = sorted(A)

    return A[0] + A[1]


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

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

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()))
print(sum(sorted(l)[:2]))

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

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,=map(int,input().split());print(sum(a)-max(a))

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