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

Solution (Python):
x,y,z=map(int,input().split(' '))
X=x+y
Y=y+z
Z=x+z
print(min(X,Y,Z))

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

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

Solution (Python):
def ringring(a: int, b: int, c: int)->int:
    return sum(sorted([a, b, c])[:2])


if __name__ == "__main__":
    a, b, c = map(int, input().split())
    ans = ringring(a, b, c)
    print(ans)

Solution (Python):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
def func(a, b, c):
    result = min((a + b), (b + c), (c + a))
    return result


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

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

res = a+b
res = a+c if a+c < res else res
res = b+c if b+c < res else res

print(res)

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

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

Solution (Python):
bells = list(map(int, input().split()))
print(sum(bells) - bells[bells.index(max(bells))])

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

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

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

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

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

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

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

Solution (Python):
argv=input().split()

a=int(argv[0])
b=int(argv[1])
c=int(argv[2])

r=a+b

if  a+c < r:
    r= a+c

if  b + c < r:
    r= b+c

print(r)

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

Solution (Python):
str = input().split()

a = int(str[0])
b = int(str[1])
c = int(str[2])

result1 = a+b
result2 = b+c
result3 = c+a

min = result1

if result2 <= min:
  min = result2
  
if result3 <= min:
  min = result3
  
print(min)

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

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

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

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

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

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

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

Solution (Python):
a = input().split()

for i in range(3):
  a[i] = int(a[i])
a.sort()

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

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

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

Solution (Python):

N = sorted(list(map(int, input().split())))
print(N[0] + N[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,max(b, c)))

Solution (Python):
a=list(map(int,input().split()))
a.sort()
print(a[0]+a[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):
l=map(int,input().split());print(sum(sorted(l)[:2]))

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

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

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

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

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

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

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

print(ans)
print()

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

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

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

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

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

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

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

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

Solution (Python):
s = list(map(int, input().split()))
s.sort()
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())
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):
b = [int(i) for i in input().split()]
b.sort()
print(b[0] + b[1])

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

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

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

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

print(sum(L)-max(L))

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

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

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

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

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

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

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

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

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

Solution (Python):
avails = input().split()
for i in range(len(avails)):
    avails[i] = int(avails[i])

avails.sort()

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

Solution (Python):
""" AtCoder """

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

abc.sort()

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

Solution (Python):
a,b,c = map(int, input().split())
T = []
T.append(a)
T.append(b)
T.append(c)
L=sorted(T)
del L[-1]
print(sum(L))

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

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

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

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

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

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

Solution (Python):

def getIntList(): return [int(x) for x in input().split()]
def db(x): 
    global debug
    if debug: print(x)

debug = False
bell = getIntList()
bell.sort()
db(bell)
print(bell[0]+bell[1])

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

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

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

print(sum(li) - max(li))

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

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

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

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

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

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

print(sum(ar_int[:2]))

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

Solution (Python):
l=[int(_) for _ in input().split()]
l.sort()
print(l[0]+l[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())))
print(a[0] + a[1])

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

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

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

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


abc066_a()

Solution (Python):
lines = list(input().split())
a = int(lines[0])
b = int(lines[1])
c = int(lines[2])
sum_list = [a+b, a+c, b+c]
print(min(sum_list))

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

result = min(A + B, B + C, C + A)
print(result)

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

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

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

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

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

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

Solution (Python):

import numpy as np
c = list(map(int,input().split()))
c.sort()
d = np.array(c)
print(d[0:2].sum())

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

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

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


if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

Solution (Python):
from statistics import mean, median,variance,stdev
import sys
import math

a = input().split()

x = []
for i in range(len(a)):
    x.append(int(a[i]))
x.sort()
print(x[0]+x[1])

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

Solution (Python):

a,b,c =map(int, input().split())
print("{}".format(min(a+b,b+c,c+a)))

Solution (Python):



def main():
    """Function."""
    a, b, c = map(int, input().split())
    print(min([a+b, a+c, b+c]))


if __name__ == "__main__":
    main()

Solution (Python):
a,b,c=[int(i) for i in 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()))
t=max(a[0],a[1],a[2])
print(str(a[0]+a[1]+a[2]-t))

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

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

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

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

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

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

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

ans = sorted(abc)
print(ans[0]+ans[1])

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

Solution (Python):
a=input().strip().split(" ")

b=[int(i) for i in a]

b.sort()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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):
num = list(map(int, input().split()))
a = num[0]
b = num[1]
c = num[2]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
def mins(nums, count):
    return sorted(nums)[:count]

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

print(sum(mins(abc, 2)))

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

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

Solution (Python):

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

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

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

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

Solution (Python):


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

Solution (Python):


INF = float('inf')


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


X = inpl()
X.sort()

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

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

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

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

l = []

l.append(a)
l.append(b)
l.append(c)



l.sort()



print(l[0] + l[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(int(a+b+c - max(a,b,c)))

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

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

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

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

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(sum(a[: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(min(a+b,a+c,b+c))

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

Solution (Python):
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b


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


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

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

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

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

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

Solution (Python):


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

if __name__ == '__main__':
    main()

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

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

Solution (Python):
import sys
import math
import collections
import itertools
import array
import inspect


sys.setrecursionlimit(1000000)



def chkprint(*args):
    names = {
        id(v): k
        for k, v in inspect.currentframe().f_back.f_locals.items()
    }
    print(', '.join(
        names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args))



def to_bin(x):
    return bin(x)[2:]


def li_input():
    return [int(_) for _ in input().split()]


def gcd(n, m):
    if n % m == 0:
        return m
    else:
        return gcd(m, n % m)


def gcd_list(L):
    v = L[0]

    for i in range(1, len(L)):
        v = gcd(v, L[i])

    return v


def lcm(n, m):
    return (n * m) // gcd(n, m)


def lcm_list(L):
    v = L[0]

    for i in range(1, len(L)):
        v = lcm(v, L[i])

    return v



def wfs_d(D, N, K):
    """
    D: 隣接行列(距離付き)
    N: ノード数
    K: 始点ノード
    """

    dfk = [-1] * (N + 1)
    dfk[K] = 0

    cps = [(K, 0)]
    r = [False] * (N + 1)
    r[K] = True
    while len(cps) != 0:
        n_cps = []
        for cp, cd in cps:
            for i, dfcp in enumerate(D[cp]):
                if dfcp != -1 and not r[i]:
                    dfk[i] = cd + dfcp
                    n_cps.append((i, cd + dfcp))
                    r[i] = True

        cps = n_cps[:]

    return dfk



def dfs_d(v, pre, dist):
    """
    v:  現在のノード
    pre: １つ前のノード
    dist: 現在の距離

    以下は別途用意する
    D: 隣接リスト(行列ではない)
    D_dfs_d: dfs_d関数で用いる，始点ノードから見た距離リスト
    """

    global D
    global D_dfs_d

    D_dfs_d[v] = dist

    for next_v, d in D[v]:
        if next_v != pre:
            dfs_d(next_v, v, dist + d)

    return




dp = None


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

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


main()

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

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=input().split()
list=[a,b,c]
list.sort(key=int)
print(int(list[0])+int(list[1]))

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

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

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

Solution (Python):
Bell = list(map(int, input().split()))
Ans = 0
Ans += min(Bell)
Bell.remove(min(Bell))
Ans += min(Bell)
print(Ans)

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

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

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

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

Solution (Python):


def main():
    lists = list(map(int, input().split()))
    lists.sort()
    print(lists[0] + lists[1])


if __name__ == '__main__':
    main()

Solution (Python):
a,b,c=map(int,input().split())
list=[a,b,c]
ans=[]
for i in range(2):
    ans.append(min(list))
    list.remove(min(list))
print(sum(ans))

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

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

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

Solution (Python):
from collections import defaultdict
import sys,heapq,bisect,math,itertools,string
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
AtoZ = [chr(i) for i in range(65,65+26)]
atoz = [chr(i) for i in range(97,97+26)]

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

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

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

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

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

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

Solution (Python):
def mins(nums, count):
    return sorted(nums)[:count]

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

print(sum(mins(abc, 2)))

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

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

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

Solution (Python):
ring_one,ring_two,ring_three = map(int,input().split())
lis = sorted([ring_one,ring_two,ring_three])
print(lis[0]+lis[1])

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

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

Solution (Python):

n=[int(i) for i in input().split()]
n.sort()
print(n[0]+n[1])

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

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

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

print(min(ans))

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

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

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

Solution (Python):


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

abc.sort()

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

Solution (Python):

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

ans = sum(bell) - max(bell)

print(ans)

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

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

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

Solution (Python):
x,y,z=map(int,input().split())
if (x+y) <= (x+z)  and (x+y)<= (y+z):
  print(x+y)
elif (x+z) <= (x+y) and (x+z) <= (y+z):
  print(x+z)
elif (y+z) <= (x+y) and (y+z) <= (x+z):
  print(y+z)
else:
  print(x+z)

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

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

Solution (Python):
x = [int(i) for i in input().split()]
x.sort()
print(x[0]+x[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=[int(s)for s in input().split()]
a.sort()
print(a[0]+a[1])

Solution (Python):
a , b ,c = map(int, input().split())
l = [a,b,c]
l.sort()
print('{}'.format(l[0]+l[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):
import sys

a, b, c = list(map(int, input().split()))
j = a + b
k = a + c
l = b + c

if j <= k and j <= l:
  print(j)
  sys.exit()
if k <= j and k <= l:
  print(k)
  sys,exit()
if l <= j and l <= k:
  print(l)
  sys.exit()

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

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

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

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

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

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