Today Patrick waits for a visit from his friend Spongebob. To prepare for the visit, Patrick needs to buy some goodies in two stores located near his house. There is a d_1 meter long road between his house and the first shop and a d_2 meter long road between his house and the second shop. Also, there is a road of length d_3 directly connecting these two shops to each other. Help Patrick calculate the minimum distance that he needs to walk in order to go to both shops and return to his house. [Image] 

Patrick always starts at his house. He should visit both shops moving only along the three existing roads and return back to his house. He doesn't mind visiting the same shop or passing the same road multiple times. The only goal is to minimize the total distance traveled.


-----Input-----

The first line of the input contains three integers d_1, d_2, d_3 (1 ≤ d_1, d_2, d_3 ≤ 10^8) — the lengths of the paths.   d_1 is the length of the path connecting Patrick's house and the first shop;  d_2 is the length of the path connecting Patrick's house and the second shop;  d_3 is the length of the path connecting both shops. 


-----Output-----

Print the minimum distance that Patrick will have to walk in order to visit both shops and return to his house.


-----Examples-----
Input
10 20 30

Output
60

Input
1 1 5

Output
4



-----Note-----

The first sample is shown on the picture in the problem statement. One of the optimal routes is: house $\rightarrow$ first shop $\rightarrow$ second shop $\rightarrow$ house.

In the second sample one of the optimal routes is: house $\rightarrow$ first shop $\rightarrow$ house $\rightarrow$ second shop $\rightarrow$ house.

Difficulty: EASY

Solutions:
a = list(map(int, input().split()))
a.sort()
total = a[0]
if a[0] + a[1] <= a[2]:
	total += a[0] + a[1]
else:
	total += a[2]
if a[1] <= a[2]:
	total += a[1]
else:
	total += a[2] + a[0]
print(total)


(d1, d2, d3) = map(int, input().split())
if d1 + d2 + d3 <= 2 * (d1 + d2) and d1 + d2 + d2 <= 2 * (d1 + d3) and (d1 + d2 + d3 <= 2 * (d2 + d3)):
	print(d1 + d2 + d3)
elif 2 * (d1 + d2) <= 2 * (d1 + d3) and 2 * (d1 + d2) <= 2 * (d2 + d3):
	print(2 * (d1 + d2))
elif 2 * (d1 + d3) <= 2 * (d2 + d3):
	print(2 * (d1 + d3))
else:
	print(2 * (d2 + d3))


(d1, d2, d3) = map(int, input().split())
D1 = 2 * d1 + 2 * d2
D2 = d1 + d3 + d2
D3 = (d1 + d3) * 2
D4 = (d2 + d3) * 2
print(min(D1, D2, D3, D4))


def main():
	(a, b, c) = map(int, input().split())
	ans = min(a, b)
	ans += min(a + b, c)
	ans += min(max(a, b), min(a, b) + c)
	print(ans)
main()


(d1, d2, d3) = map(int, input().split())
dist1 = d1 + d2 + d3
dist2 = d1 + d3 + d3 + d1
dist3 = d2 + d3 + d3 + d2
dist4 = d1 + d1 + d2 + d2
print(min(dist1, dist2, dist3, dist4))


(x, y, z) = map(int, input().split())
print(min(2 * x + 2 * y, 2 * x + 2 * z, 2 * y + 2 * z, x + y + z))


(d1, d2, d3) = map(int, input().split())
ds = {'d1': d1, 'd2': d2, 'd3': d3}
print(min(d1 * 2 + d2 * 2, d1 + d2 + d3, d3 * 2 + d2 * 2, d3 * 2 + d1 * 2))


def single_integer():
	return int(input())

def multi_integer():
	return map(int, input().split())

def string():
	return input()

def multi_string():
	return input().split()
(d1, d2, d3) = multi_integer()
print(min(d1 + d2 + d3, 2 * (d1 + d2), 2 * (d1 + d3), 2 * (d2 + d3)))


(d1, d2, d3) = [int(i) for i in input().split()]
if d1 > d2 + d3:
	print(2 * (d2 + d3))
elif d2 > d1 + d3:
	print(2 * (d1 + d3))
elif d3 > d1 + d2:
	print(2 * (d1 + d2))
else:
	print(d1 + d2 + d3)


(d1, d2, d3) = map(int, input().split())
a = d1 + d3 + d2
b = d1 + d1 + d2 + d2
c = d1 + d3 + d3 + d1
d = d2 + d3 + d3 + d2
print(min(min(a, b), min(d, c)))


(d1, d2, d3) = map(int, input().split())
ans = min(int(d1 * 2 + d2 * 2), d1 + d2 + d3, int(d1 * 2 + d3 * 2), int(d2 * 2 + d3 * 2))
print(ans)


def solve(d1, d2, d3):
	return min(d1 + d3 + d2, 2 * d1 + 2 * d2, 2 * d1 + 2 * d3, 2 * d2 + 2 * d3)
(d1, d2, d3) = map(int, input().split())
print(solve(d1, d2, d3))


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


s = input()
a = s.split()
for i in range(len(a)):
	a[i] = int(a[i])
min = a[0] + a[1] + a[2]
if (a[0] + a[1]) * 2 < min:
	min = (a[0] + a[1]) * 2
elif (a[0] + a[2]) * 2 < min:
	min = (a[0] + a[2]) * 2
elif (a[1] + a[2]) * 2 < min:
	min = (a[1] + a[2]) * 2
print(min)


from sys import stdin
d = list(map(int, stdin.readline().split()))
d.sort()
print(min((d[0] + d[1]) * 2, d[0] + d[1] + d[2]))


z = list(map(int, input().split()))
if z[0] + z[1] < z[2]:
	print(z[0] * 2 + z[1] * 2)
elif z[0] > z[1] + z[2]:
	print(z[1] * 2 + z[2] * 2)
elif z[1] > z[0] + z[2]:
	print(z[0] * 2 + z[2] * 2)
else:
	print(z[0] + z[1] + z[2])


l = list(map(int, input().split()))
(a, b, c) = (l[0], l[1], l[2])
print(min(2 * (a + b), a + b + c, 2 * (a + c), 2 * (c + b)))


data = [int(info) for info in input().split(' ')]
result = 0
if data[1] <= data[0]:
	(data[1], data[0]) = (data[0], data[1])
if data[1] >= data[0]:
	result += data[0]
	if data[0] + data[1] > data[2]:
		result += data[2]
	else:
		result += data[0] + data[1]
	if data[1] > data[2] + data[0]:
		result += data[2] + data[0]
	else:
		result += data[1]
print(result)


(a, b, c) = map(int, input().split())
h = 0
ans = min(a * 2 + b * 2, a + b + c, a * 2 + c * 2, b * 2 + c * 2)
print(ans)


d = [int(x) for x in input().split()]
print(min(2 * d[0] + 2 * d[1], 2 * d[0] + 2 * d[2], d[0] + d[2] + d[1], 2 * d[1] + 2 * d[2]))


(x, y, z) = input().split()
x = int(x)
y = int(y)
z = int(z)
a = x + y + z
if 2 * (x + y) < a:
	a = 2 * (x + y)
if 2 * (min(x, y) + z) < a:
	a = 2 * (min(x, y) + z)
print(a)


(d1, d2, d3) = [int(a) for a in input().split()]
print(min(2 * (d1 + d2), d1 + d2 + d3, 2 * (d1 + d3), 2 * (d2 + d3)))


(d1, d2, d3) = [int(i) for i in input().split()]
print(min(2 * min(d1, d2) + 2 * max(d1, d2), min(d1, d2) + d3 + min(max(d1, d2), d3 + min(d1, d2))))


(d1, d2, d3) = map(int, input().split())
print(min(d1 + min(d1 + d2, d3) + min(d2, d3 + d1), d2 + min(d1 + d2, d3) + min(d1, d3 + d2)))


(d1, d2, d3) = map(int, input().split())
dis1 = d1 + d2 + d3
dis2 = 2 * d1 + 2 * d2
dis3 = d1 + d3 + d3 + d1
dis4 = d2 + d3 + d3 + d2
print(min(dis1, min(dis2, min(dis3, dis4))))


a = list(map(int, input().split()))
s = 2 * (a[0] + a[1])
s2 = 2 * (a[1] + a[2])
s3 = 2 * (a[2] + a[0])
s4 = a[0] + a[1] + a[2]
print(min(s, s2, s3, s4))


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


(d1, d2, d3) = map(int, input().split())
if d1 >= d2:
	print(d2 + min(d1 + d2, d3) + min(d1, d3 + d2))
else:
	print(d1 + min(d1 + d2, d3) + min(d2, d3 + d1))


y = input().split()
d1 = int(y[0])
d2 = int(y[1])
d3 = int(y[2])
v = 2 * d2 + 2 * d3
x = d1 + d2 + d3
y = 2 * d1 + 2 * d2
z = 2 * d1 + 2 * d3
print(min(v, x, y, z))


import itertools as it
import functools
import operator
import collections
import math
import sys
BIGMOD = 1000000007

def solve(d1, d2, d3):
	return min(d1 + d2 + d3, 2 * (d1 + d2), 2 * (d1 + d3), 2 * (d2 + d3))

def p(*args, **kwargs):
	return print(*args, file=sys.stderr, **kwargs)

def main():
	[d1, d2, d3] = map(int, input().strip().split())
	result = solve(d1, d2, d3)
	print(result)
main()


try:
	while True:
		(a, b, c) = map(int, input().split())
		if a > b:
			(a, b) = (b, a)
		d = min(a + b, c)
		print(a + d + min(b, a + d))
except EOFError:
	pass


(a, b, c) = map(int, input().split())
(e, f) = (min(a, min(b, c)), max(a, max(b, c)))
g = a + b + c - e - f
if e + g < f:
	print(2 * (e + g))
else:
	print(a + b + c)


import math
import os
import random
import re
import sys
(d1, d2, d3) = map(int, input().rstrip().split())
d = 0
if d2 + d3 > d1:
	d = d + d1
else:
	d = d + d2 + d3
if d1 + d2 > d3:
	d = d + d3
else:
	d = d + d1 + d2
if d1 + d3 > d2:
	d = d + d2
else:
	d = d + d1 + d3
print(d)


(d1, d2, d3) = map(int, input().split())
n1 = d1 + d3 + d2
n2 = d1 + d3 + d3 + d1
n3 = d2 + d2 + d1 + d1
n4 = d2 + d3 + d3 + d2
print(min(n1, n2, n3, n4))


(x, y, z) = map(int, input().split())
ans1 = x + x + y + y
a = x + y + z
b = min(x + x + z + z, y + y + z + z)
ans = min(a, b)
print(min(ans, ans1))


(d1, d2, d3) = [int(s) for s in input().split()]
print(min(d1 + d2 + d3, 2 * (d1 + d2), 2 * (d1 + d3), 2 * (d3 + d2)))


(d1, d2, d3) = map(int, input().split())
p = d1 * 2 + d2 * 2
q = d1 + d2 + d3
r1 = d1 * 2 + d3 * 2
r2 = d2 * 2 + d3 * 2
print(min(p, q, r1, r2))


(a, b, c) = sorted(list(map(int, input().split())))
ans = 0
if a + b <= c:
	ans = 2 * (a + b)
else:
	ans = a + b + c
print(ans)


i = lambda : map(int, input().split())
(d1, d2, d3) = i()
min1 = min(d1 + d2 + d3, 2 * (d1 + d2))
min2 = min(2 * (d1 + d3), 2 * (d2 + d3))
print(min(min1, min2))


def main():
	numbers = input().split()
	(d1, d2, d3) = (int(x) for x in numbers)
	print(bestRoute(d1, d2, d3))

def bestRoute(d1, d2, d3):
	r1 = 2 * d2 + 2 * d3
	r2 = 2 * d1 + 2 * d3
	r3 = 2 * d1 + 2 * d2
	r4 = d1 + d2 + d3
	return min(r1, r2, r3, r4)
main()


(a, b, c) = sorted(map(int, input().split()))
if a == b == c or a + b >= c:
	print(a + b + c)
else:
	print(2 * a + 2 * b)


s = input()
l = s.split(' ')
d1 = int(l[0])
d2 = int(l[1])
d3 = int(l[2])
m1 = d1 + d2 + d3
m2 = 2 * d1 + 2 * d2
m3 = 2 * d1 + 2 * d3
m4 = 2 * d3 + 2 * d2

def min(a, b):
	if a >= b:
		return b
	else:
		return a
print(min(min(m1, m2), min(m3, m4)))


(a, b, m) = [int(i) for i in input().split()]
answer = 1000000000
if 2 * a + 2 * b < answer:
	answer = 2 * a + 2 * b
if a + b + m < answer:
	answer = a + b + m
if 2 * a + 2 * m < answer:
	answer = 2 * a + 2 * m
if 2 * b + 2 * m < answer:
	answer = 2 * b + 2 * m
print(answer)


INF = 1000000000
(d1, d2, d3) = map(int, input().split())
adjlist = [[] for i in range(3)]
adjlist[0] = [0, d1, d2]
adjlist[1] = [d1, 0, d3]
adjlist[2] = [d2, d3, 0]
ans = INF

def dfs(dis, loc, steps, vis):
	if steps > 6:
		return
	if loc == 0 and vis == [True, True, True]:
		global ans
		ans = min(ans, dis)
		return
	vis[loc] = True
	for nextNode in range(3):
		oldVal = vis[nextNode]
		vis[nextNode] = True
		dfs(dis + adjlist[loc][nextNode], nextNode, steps + 1, vis)
		vis[nextNode] = oldVal
vis = [False for i in range(3)]
dfs(0, 0, 0, vis)
print(ans)


(d_s1, d_s2, d_ss) = map(int, input().split())
ans1 = d_s1 + min(d_ss + d_s2, 2 * d_ss + d_s1, d_s1 + 2 * d_s2)
ans2 = d_s2 + min(d_ss + d_s1, 2 * d_ss + d_s2, d_s2 + 2 * d_s1)
ans = min(ans1, ans2)
print(ans)


(a, b, c) = list(map(int, input().split()))
d = 0
d += min(a, b)
if c > a + b:
	d += a + b
else:
	d += c
if max(a, b) > min(a, b) + c:
	d += min(a, b) + c
else:
	d += max(a, b)
print(d)


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


d = list(map(int, input().split()))
d1 = d[0]
d2 = d[1]
d3 = d[2]
print(min(d1 + d3 + d2, d1 + d1 + d2 + d2, d2 + d3 + d3 + d2, d1 + d3 + d3 + d1))


(a, b, c) = map(int, input().split())
if a <= b:
	print(a + min(a + b, c) + min(b, c + a))
else:
	print(b + min(a + b, c) + min(a, c + b))


L = [d1, d2, d3] = [int(x) for x in input().split()]
print(min(d1, d2 + d3) + min(d2, d3 + d1) + min(d3, d1 + d2))


(d1, d2, d3) = input().split()
d1 = int(d1)
d2 = int(d2)
d3 = int(d3)
sum1 = 0
res = 0
count = 0
xx = 0
sum1 = d1 + d2 + d3
res = d1 * 2 + d2 * 2
xx = d1 * 2 + d3 * 2
count = d2 * 2 + d3 * 2
if sum1 <= res and sum1 <= count and (sum1 <= xx):
	print(sum1)
elif res <= count and res <= xx:
	print(res)
elif count <= xx:
	print(count)
else:
	print(xx)


def solve(d1, d2, d3):
	return min(2 * d1 + 2 * d2, d1 + d2 + d3, 2 * (d1 + d3), 2 * (d2 + d3))

def __starting_point():
	(d1, d2, d3) = [int(x) for x in input().split()]
	print(solve(d1, d2, d3))
__starting_point()


(a, b, c) = map(int, input().split())
s = a * 2 + b * 2
p = a + c + b
k = a * 2 + c * 2
e = b * 2 + c * 2
print(min(s, p, k, e))


(d1, d2, d3) = map(int, input().split())
s1 = d1 + d2 + d3
s2 = 2 * (d1 + d2)
s3 = 2 * (d2 + d3)
s4 = 2 * (d1 + d3)
print(int(min(s1, s2, s3, s4)))


(a, b, c) = map(int, input().split())
ans1 = 2 * a + 2 * b
ans2 = a + b + c
ans3 = 2 * a + 2 * c
ans4 = 2 * b + 2 * c
print(min(ans1, ans2, ans3, ans4))


dis = list(map(int, input().split()))
a = dis[0]
b = dis[1]
c = dis[2]
if a > b:
	count = b
	count += min(a + b, c)
	count += min(a, b + c)
	print(count)
else:
	count = a
	count += min(a + b, c)
	count += min(b, a + c)
	print(count)


(d1, d2, d3) = [int(i) for i in input().split()]
sum = 0
sum += min(d1, d2)
if sum == d1:
	sum += min(d1 + d2, d3)
	sum += min(d2, d3 + d1)
elif sum == d2:
	sum += min(d1 + d2, d3)
	sum += min(d1, d3 + d2)
print(sum)


d = [int(s) for s in input().split(' ')]
print(min(sum(d), 2 * (d[0] + d[1]), 2 * (d[0] + d[2]), 2 * (d[1] + d[2])))


l = list(map(int, input().split()))
print(min(l[0] * 2 + l[2] * 2, l[0] + l[1] + l[2], l[0] * 2 + l[1] * 2, l[2] * 2 + l[1] * 2))


(a, b, c) = [int(i) for i in input().split()]
l = []
s = a + b + c
l.append(s)
x = a * 2 + b * 2
l.append(x)
y = a * 2 + c * 2
l.append(y)
z = b * 2 + c * 2
l.append(z)
print(min(l))


(d1, d2, d3) = map(int, input().split())
mn = min(d1, d2)
mx = max(d1, d2)
d = mn
op1 = d3 + mx
op2 = mn + mx * 2
op3 = mn + d3 * 2
d += min(op1, op2, op3)
print(d)


(d1, d2, d3) = map(int, input().split())
sum = 0
if d1 < d2 + d3:
	sum = sum + d1
else:
	sum = sum + (d3 + d2)
if d1 + d2 < d3:
	sum = sum + (d1 + d2)
else:
	sum = sum + d3
if d2 < d3 + d1:
	sum = sum + d2
else:
	sum = sum + (d3 + d1)
print(sum)


(a, b, c) = [int(x) for x in input().split()]
ans = 2 * (a + b + c)
if c > a + b:
	ans = 2 * (a + b)
else:
	if c < a:
		ans = 2 * (b + c)
	if c < b:
		ans = min(ans, 2 * (a + c))
	ans = min(ans, a + b + c)
print(ans)


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


ds = [int(n) for n in input().strip().split(' ')]
print(min([ds[0] + ds[1] + ds[2], ds[0] * 2 + ds[1] * 2, ds[0] * 2 + ds[2] * 2, ds[1] * 2 + ds[2] * 2]))


(a, b, c) = [int(i) for i in input().split(' ')]
ans = []
ans.append(2 * (a + b))
ans.append((min(a, b) + c) * 2)
ans.append(a + b + c)
print(min(ans))


(d1, d2, d3) = map(int, input().split())
s = 0
if d1 < d2 + d3:
	s += d1
else:
	s += d2 + d3
if d1 + d2 < d3:
	s += d1 + d2
else:
	s += d3
if d2 < d1 + d3:
	s += d2
else:
	s += d1 + d3
print(s)


(d1, d2, d3) = map(int, input().split())
first_pass = int(2 * d1 + 2 * d2)
second_pass = int(d1 + d3 + d2)
third_pass = int(2 * d1 + 2 * d3)
fourth_pass = int(2 * d2 + 2 * d3)
print(min(first_pass, second_pass, third_pass, fourth_pass))


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


(ab, ac, bc) = map(int, input().split())
route = 0
if ab <= ac:
	route += ab
	if bc <= ab or bc + ac <= ab + ac + ac:
		route += bc
		if ac <= bc + ab:
			route += ac
		else:
			route += bc + ab
	else:
		route += ab
		route += ac + ac
else:
	route += ac
	if bc <= ab:
		route += bc
		if ab <= bc + ac:
			route += ab
		else:
			route += bc + ac
	else:
		route += ac + ab
		route += ab
print(route)


import itertools, functools, math

def solve():
	(d1, d2, d3) = map(int, input().split())
	return min(2 * d1 + 2 * d2, d1 + d3 + min(d2, d3 + d1), d2 + d3 + min(d1, d3 + d2))
print(solve())


(d1, d2, d3) = map(int, input().split())
temp = 2 * d1 + 2 * d2
temp1 = d1 + d3 + d2
temp2 = 2 * d1 + 2 * d3
temp3 = 2 * d2 + 2 * d3
print(min(temp, temp1, temp2, temp3))


from collections import Counter

def solve():
	(d1, d2, d3) = list(map(int, input().split()))
	n = min(d1, d2)
	res = min(d2 * 2 + d1 * 2, n + d3 + max(d1, d2), 2 * n + 2 * d3)
	return res
print(solve())


(d1, d2, d3) = map(int, input().split())
cost = 0
if d1 < d2:
	cost += d1
	route1 = d3 + d2
	route2 = d1 + 2 * d2
	route3 = 2 * d3 + d1
	cost += min(route1, route2, route3)
else:
	cost += d2
	route1 = d3 + d1
	route2 = d2 + 2 * d1
	route3 = 2 * d3 + d2
	cost += min(route1, route2, route3)
print(cost)


(a, b, c) = [int(i) for i in input().split()]
n = []
d = 2 * a + 2 * b
e = a + b + c
f = 2 * a + 2 * c
g = 2 * b + 2 * c
n.append(d)
n.append(e)
n.append(f)
n.append(g)
print(min(n))


(a, b, c) = map(int, input().split())
p = 0
if c < a + b:
	if c + a < b:
		p = 2 * (a + c)
	elif c + b < a:
		p = 2 * (b + c)
	else:
		p = a + b + c
else:
	p = 2 * (a + b)
print(p)


n = input()
l = n.split(' ')
arr = []
for i in l:
	arr.append(int(i))
d = arr[0] + arr[1] + arr[2]
d12 = 2 * arr[0] + 2 * arr[1]
d23 = 2 * arr[1] + 2 * arr[2]
d13 = 2 * arr[0] + 2 * arr[2]
mn = min(d, min(d12, min(d13, d23)))
print(mn)


(a, b, c) = [int(x) for x in input().split()]
d = a + b + c
e = 2 * a + 2 * b
f = 2 * b + 2 * c
g = 2 * a + 2 * c
print(min(d, e, f, g))


(d1, d2, d3) = sorted(map(int, input().split()))
print(min(2 * (d1 + d2), d1 + d2 + d3))


(d1, d2, d3) = [int(x) for x in input().split()]
print(min(d1 * 2 + d2 * 2, d1 + d2 + d3, d1 * 2 + d3 * 2, d2 * 2 + d3 * 2))


a = input().split()
for i in range(3):
	a[i] = int(a[i])
sum = a[0] + a[1] + a[2]
ans = sum
for i in range(3):
	if 2 * (sum - a[i]) < ans:
		ans = 2 * (sum - a[i])
print(ans)


string = input().split(' ')
d1 = int(string[0])
d2 = int(string[1])
d3 = int(string[2])
method1 = d1 + d1 + d2 + d2
method2 = d1 + d3 + d2
method3 = d1 + d3 + d3 + d1
method4 = d2 + d3 + d3 + d2
print(min(method1, method2, method3, method4))


(a, b, ab) = map(int, input().split())
print(min(a + b + ab, 2 * a + 2 * b, 2 * a + 2 * ab, 2 * b + 2 * ab))


def find_shortest_way(d):
	d.sort()
	if d[0] + d[1] < d[2]:
		return 2 * (d[0] + d[1])
	return sum(d)

def main():
	d = list(map(int, input().split()))
	print(find_shortest_way(d))
main()


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


(d1, d2, d3) = input().split()
d1 = int(d1)
d2 = int(d2)
d3 = int(d3)
b = d1 + d2 + d3
d = 2 * d1 + 2 * d2
e = d1 + d3 + d3 + d1
f = d2 + d3 + d3 + d2
c = min(b, d, e, f)
print(c)


(a, b, c) = map(int, input().split())
for i in range(100):
	a = min(a, b + c)
	b = min(b, a + c)
	c = min(c, a + b)
print(a + b + c)


x = input().split()
d1 = int(x[0])
d2 = int(x[1])
d3 = int(x[2])
s = 0
if d1 > d2:
	s += d2
	if d1 > d2 + d3:
		s += d3 + d3 + d2
	elif d3 <= d1 + d2:
		s += d3
		s += d1
	else:
		s += d1 + d2
		s += d1
else:
	s += d1
	if d2 > d1 + d3:
		s += d3 + d3 + d1
	elif d3 <= d1 + d2:
		s += d3
		s += d2
	else:
		s += d1 + d2
		s += d2
print(s)


(m, n, k) = input().split()
x = max(int(m), int(n), int(k))
y = min(int(m), int(n), int(k))
z = int(m) + int(n) + int(k) - x - y
if x == y == z:
	print(x + y + z)
elif y + z >= x:
	print(x + y + z)
else:
	print(2 * (y + z))


adj = [[0] * 3 for x in range(3)]
(a, b, c) = map(int, input().split())
adj[0][1] = adj[1][0] = a
adj[0][2] = adj[2][0] = b
adj[1][2] = adj[2][1] = c
for k in range(3):
	for i in range(3):
		for j in range(3):
			adj[i][j] = min(adj[i][j], adj[i][k] + adj[k][j])
print(adj[0][1] + adj[1][2] + adj[2][0])


(a, b, c) = [int(nhap) for nhap in input().split()]
kq = 0
if a + b <= c:
	print(2 * (a + b))
elif a + c < b:
	print(2 * (a + c))
elif b + c < a:
	print(2 * (b + c))
else:
	print(a + b + c)


def main():
	(d1, d2, d3) = map(int, input().split())
	s = min(d1, d2 + d3) + min(d3, d1 + d2) + min(d2, d3 + d1)
	return s
print(main())


(d1, d2, d3) = map(int, input().split())
x = []
x.append(2 * (d1 + d2))
x.append(d1 + d2 + d3)
x.append(2 * (d2 + d3))
x.append(2 * (d1 + d3))
print(min(x))


(d1, d2, d3) = tuple(map(int, input().split()))
print(min(d1 + d2 + d3, 2 * d1 + 2 * d2, 2 * d2 + 2 * d3, 2 * d1 + 2 * d3))


(d1, d2, d3) = list(map(int, input().split()))
l1 = d1 + d2 + d3
l2 = 2 * (d1 + d2)
l3 = 2 * (d2 + d3)
l4 = 2 * (d3 + d1)
l = min(l1, l2, l3, l4)
print(int(l))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	a = LI()
	r = sum(a)
	t = sum(a[:2]) * 2
	if r > t:
		r = t
	t = min(a[:2]) * 2 + a[2] * 2
	if r > t:
		r = t
	return r
print(main())


line = str(input()).split()
line = [int(it) for it in line]
print(min(2 * (sum(line) - max(line)), sum(line)))


(d1, d2, d3) = map(int, input().split())
a = 0
b = 0
if d1 > d2 and d1 > d3:
	a = 2 * (d2 + d3)
elif d2 > d3 and d2 > d1:
	a = 2 * (d1 + d3)
else:
	a = 2 * (d1 + d2)
b = d1 + d2 + d3
if a < b:
	print(a)
else:
	print(b)


n = list(map(int, input().split()))
a = n[0] + n[1] + n[2]
b = 2 * n[0] + 2 * n[1]
c = 2 * n[0] + 2 * n[2]
d = 2 * n[1] + 2 * n[2]
print(min(a, b, c, d))


arr = [0] * 6
arr = list(map(int, input().split()))
a = arr[0]
b = arr[1]
c = arr[2]
print(min(a + a + b + b, min(a + b + c, min(a + a + c + c, b + b + c + c))))


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


(d1, d2, d3) = map(int, input().split())
p1 = d1 + d3 + d2
p2 = 2 * d1 + 2 * d2
p3 = 2 * d2 + 2 * d3
p4 = 2 * d1 + 2 * d3
print(min([p1, p2, p3, p4]))


s = input().split()
d1 = int(s[0])
d2 = int(s[1])
d3 = int(s[2])
c1 = d1 * 2 + d2 * 2
c2 = d1 + d2 + d3
c3 = d1 * 2 + d3 * 2
c4 = d2 * 2 + d3 * 2
li = list()
li.append(c1)
li.append(c2)
li.append(c3)
li.append(c4)
li.sort()
print(li[0])


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


(d1, d2, d3) = map(int, input().split())
s = 0
s += min(d1, d2)
s += min(d1 + d2, d3)
s += min(max(d1, d2), min(d1 + d2, d3) + min(d1, d2))
print(s)


(d1, d2, d3) = [int(x) for x in input().split()]
combination1 = d1 + d3 + d2
combination2 = d1 + d3 + d3 + d1
combination3 = d2 + d2 + d1 + d1
combination4 = d2 + d3 + d3 + d2
print(min(combination1, combination2, combination3, combination4))


masstr = input().split(' ')
d1 = int(masstr[0])
d2 = int(masstr[1])
d3 = int(masstr[2])
way1 = d1 * 2 + d2 * 2
way2 = d1 + d3 + d2
way3 = d1 * 2 + d3 * 2
way4 = d2 * 2 + d3 * 2
print(min(way1, way2, way3, way4))


d = list(map(int, input().split()))
print(min(sum(d), 2 * (d[0] + d[1]), 2 * (d[0] + d[2]), 2 * (d[1] + d[2])))


x = [int(i) for i in input().split()]
print(min(2 * x[0] + 2 * x[1], sum(x), 2 * x[1] + 2 * x[2], 2 * x[0] + 2 * x[2]))


distances = input()
dis_str = distances.split()
dis = []
for x in dis_str:
	dis.append(int(x))
route1 = dis[0] + dis[2] + dis[1]
route2 = 2 * dis[0] + 2 * dis[1]
route3 = 2 * dis[0] + 2 * dis[2]
route4 = 2 * dis[1] + 2 * dis[2]
result = min(route1, route2, route3, route4)
print(result)


(x, y, z) = map(int, input().split())
if x + y <= z:
	print(x * 2 + y * 2)
elif x == y == z:
	print(x * 3)
elif x > y and x > z:
	print(y * 2 + z * 2)
elif y > x and y > z:
	print(x * 2 + z * 2)
else:
	print(x + y + z)


(d1, d2, d3) = map(int, input().strip().split())
print(min(d1 + d2 + d3, 2 * (d1 + d2), 2 * (d2 + d3), 2 * (d1 + d3)))


def solve(test):
	(a, b, c) = map(int, input().split())
	ans = a + b + min(a + b, c)
	ans = min(ans, 2 * (a + c), 2 * (b + c))
	print(ans)
t = 1
for _ in range(t):
	solve(_ + 1)


(d1, d2, d3) = (int(num) for num in input().split())
print(min(2 * (d1 + d2), d1 + d2 + d3, 2 * (d1 + d3), 2 * (d2 + d3)))


(a, b, c) = list(map(int, input().split()))
z1 = a + b + c
z2 = 2 * a + 2 * b
z3 = 2 * a + 2 * c
z4 = 2 * b + 2 * c
print(min(z1, z2, z3, z4))


s = list(map(int, input().split(' ')))
d1 = s[0]
d2 = s[1]
d3 = s[2]
k = d1 + d2 + d3
l = 2 * (d1 + d2)
f = 2 * (d1 + d3)
g = 2 * (d2 + d3)
s = [k, l, f, g]
s.sort()
print(s[0])


(d1, d2, d3) = map(int, input().split())
k1 = d1 + d2 + d3
k2 = d1 + d3 + d3 + d1
k3 = d2 + d2 + d1 + d1
k4 = d2 + d3 + d3 + d2
print(min(k1, k2, k3, k4))


(d1, d2, d3) = map(int, input().split())
a = [0] * 4
a[0] = (d1 + d2) * 2
a[1] = d1 + d2 + d3
a[2] = (d2 + d3) * 2
a[3] = (d1 + d3) * 2
a.sort()
print(a[0])


x = [int(a) for a in input().split()]
x = sorted(x)
a = x[0] + x[0] + x[1] + x[1]
b = x[0] + x[1] + x[2]
print(min(a, b))


(d1, d2, d3) = map(int, input().split())
x = d1 + d2 + d3
y = d1 + d1 + (d2 + d2)
w = d1 + d1 + (d3 + d3)
w2 = d2 + d2 + (d3 + d3)
if x <= y and x <= w and (x <= w2):
	print(x)
elif y < x and y < w and (y < w2):
	print(y)
elif w < x and w < y and (w < w2):
	print(w)
else:
	print(w2)


i = sorted(list(map(int, input().split())))
print(min((i[0] + i[1]) * 2, i[0] + i[2] + i[1]))


(a, b, c) = map(int, input().split())
z = a + b + c
x = 2 * (a + b)
v = 2 * (b + c)
n = 2 * (c + a)
print(min(z, x, v, n))


(one, two, between) = map(int, input().split())
a = 2 * one + 2 * two
b = one + between + two
c = 2 * one + 2 * between
d = 2 * two + 2 * between
print(min(a, b, c, d))


temp = map(int, input().split(' '))
(a, b, c) = temp
k = 2 * (a + b)
k1 = a + b + c
k2 = 2 * b + 2 * c
k3 = 2 * (a + c)
print(min(k, k1, k2, k3))


def s(n, m):
	if n == 1 and m == 1:
		return 1
	else:
		return s(max(n - 1, 1), m) + s(n, max(m - 1, 1))
(m, n, a) = [int(i) for i in input().split()]
print(min(m, n + a) + min(n, m + a) + min(m + n, a))


ls = list()
ls1 = list()
s = input().split()
for i in s:
	ls1.append(int(i))
ls.append(ls1[0] + ls1[1] + ls1[2])
ls.append(2 * (ls1[0] + ls1[1]))
ls.append(2 * (ls1[1] + ls1[2]))
ls.append(2 * (ls1[2] + ls1[0]))
print(min(ls))


(n, nn, nnn) = map(int, input().split())
n0 = n + nn + nnn
n1 = 2 * (n + nn)
n2 = 2 * (n + nnn)
n3 = 2 * (nn + nnn)
print(min(n1, n2, n3, n0))


a = [int(j) for j in input().split()]
print(min(2 * a[0] + 2 * a[1], 2 * a[1] + 2 * a[2], 2 * a[2] + 2 * a[0], a[0] + a[1] + a[2]))


import sys
(d1, d2, d3) = map(int, sys.stdin.readline().split())
ans = min(2 * (d1 + d2), 2 * (d1 + d3), 2 * (d2 + d3), d1 + d2 + d3)
print(ans)


from sys import stdin
d = [int(x) for x in stdin.readline().split()]
print(min(2 * d[0] + 2 * d[1], 2 * d[0] + 2 * d[2], d[0] + d[2] + d[1], 2 * d[1] + 2 * d[2]))


(d1, d2, d3) = input().split(' ')
d1 = int(d1)
d2 = int(d2)
d3 = int(d3)
if d2 > 2 * (d1 + d3):
	print(2 * (d1 + d3))
elif d1 > 2 * (d2 + d3):
	print(2 * (d2 + d3))
elif (2 * d1 < d3) & (2 * (d1 + d2) < d1 + d2 + d3):
	print(2 * (d1 + d2))
elif 2 * (d1 + d3) < d1 + d2 + d3:
	print(2 * (d1 + d3))
elif 2 * (d2 + d3) < d1 + d2 + d3:
	print(2 * (d2 + d3))
else:
	print(d1 + d2 + d3)


(house_and_shop1, house_and_shop2, shop1_and_shop2) = map(int, input().split())
cnt = house_and_shop1
if house_and_shop1 + house_and_shop2 <= shop1_and_shop2:
	cnt += house_and_shop1 + house_and_shop2
else:
	cnt += shop1_and_shop2
if house_and_shop2 <= shop1_and_shop2 + house_and_shop1:
	cnt += house_and_shop2
else:
	cnt += house_and_shop1 + shop1_and_shop2
cnt2 = house_and_shop2
if house_and_shop1 + house_and_shop2 <= shop1_and_shop2:
	cnt2 += house_and_shop1 + house_and_shop2
else:
	cnt2 += shop1_and_shop2
if house_and_shop1 <= shop1_and_shop2 + house_and_shop2:
	cnt2 += house_and_shop1
else:
	cnt2 += house_and_shop2 + shop1_and_shop2
print(min(cnt2, cnt))


l = sorted([int(i) for i in input().split(' ')])
print(min(sum(l), 2 * (l[0] + l[1])))


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


(a, b, c) = map(int, input().split())
tams = []
tams.append(a + b + c)
tams.append(2 * a + 2 * b)
tams.append(2 * a + 2 * c)
tams.append(2 * b + 2 * c)
tams.sort()
print(tams[0])


def omegalul():
	li = list(map(int, input().split()))
	res1 = li[0] + li[1] + li[2]
	res2 = li[0] * 2 + li[1] * 2
	res3 = li[0] * 2 + li[2] * 2
	res4 = li[1] * 2 + li[2] * 2
	arr = [res1, res2, res3, res4]
	return min(arr)
print(omegalul())


def main():
	mode = 'filee'
	if mode == 'file':
		f = open('test.txt', 'r')
	get = lambda : [int(x) for x in (f.readline() if mode == 'file' else input()).split()]
	[a, b, c] = get()
	ans = min(a + b + c, 2 * (a + c), 2 * (b + c), 2 * (a + b))
	print(ans)
	if mode == 'file':
		f.close()
main()


def solve():
	(d1, d2, d3) = [int(value) for value in input().split(' ')]
	return min([d2 * 2 + d3 * 2, d1 * 2 + d3 * 2, d1 * 2 + d2 * 2, d1 + d2 + d3])
print(solve())


(d1, d2, d3) = [int(i) for i in input().split()]
res = min(d1 + d2 + d3, d1 + d1 + d2 + d2)
res = min(d1 + d3 + d1 + d3, res)
res = min(d2 + d3 + d2 + d3, res)
print(res)


ins = list(map(int, input().split()))
d1 = ins[0]
d2 = ins[1]
d3 = ins[2]
mins = 2 * d1 + 2 * d2
if mins > d1 + d2 + d3:
	mins = d1 + d2 + d3
if mins > 2 * d1 + 2 * d3:
	mins = 2 * d1 + 2 * d3
if mins > 2 * d2 + 2 * d3:
	mins = 2 * d2 + 2 * d3
print(mins)


(d1, d2, d3) = map(int, input().split())
if d2 >= d1:
	if d3 >= d1 + d2:
		print(d1 + d1 + d2 + d2)
	elif d3 + d1 >= d2:
		print(d1 + d3 + d2)
	else:
		print(d1 + d3 + d3 + d1)
elif d3 >= d2 + d1:
	print(d2 + d2 + d1 + d1)
elif d3 + d2 >= d1:
	print(d2 + d3 + d1)
else:
	print(d2 + d3 + d3 + d2)


(a, b, c) = map(int, input().split())
ans = 0
cur = 0
ans += min(a, b)
if ans == a:
	cur = 1
else:
	cur = 2
ans += min(a + b, c)
if cur == 1:
	cur = 2
else:
	cur = 1
if cur == 1:
	ans += min(a, c + b)
else:
	ans += min(b, c + a)
print(ans)


(d1, d2, d3) = map(int, input().split())
a = [d1 + d2 + d3, 2 * d1 + 2 * d2, 2 * d1 + 2 * d3, 2 * d2 + 2 * d3]
print(min(a))


import sys
for line in sys.stdin:
	input = list(map(int, line.strip().split(' ')))
	print(min(2 * (input[0] + input[1]), input[0] + input[1] + input[2], (input[0] + input[2]) * 2, (input[1] + input[2]) * 2))


import os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
(a, b, c) = map(int, input().split())
print(min(min(min(a + b + c, 2 * a + 2 * b), 2 * a + 2 * c), 2 * b + 2 * c))


l = list(map(int, input().split(' ')))
l.sort()
a = l[0] + l[1] + l[2]
b = l[0] * 2 + l[1] * 2
if l[0] == l[1] == l[2]:
	print(l[0] * 3)
else:
	print(a if a < b else b)


def main():
	d = [int(_) for _ in input().split()]
	print(min(sum(d), (d[0] + d[1]) * 2, (d[1] + d[2]) * 2, (d[0] + d[2]) * 2))
main()


(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
y = a + b + c
z = 2 * (a + b)
x = 2 * (a + c)
w = 2 * (b + c)
i = [y, z, x, w]
print(min(i))


(d1, d2, d3) = [int(x) for x in input().split()]
a = [d1 + d1 + d2 + d2, d1 + d3 + d2, d1 + d1 + d3 + d3, d2 + d2 + d3 + d3]
print(int(min(a)))


(d1, d2, d3) = map(int, input().split())
option1 = 2 * d1 + 2 * d2
option2 = d1 + d2 + d3
option3 = 2 * (min(d1, d2) + d3)
print(min(min(option1, option2), option3))


f = lambda : map(int, input().split())
l = sorted(list(f()))
print([2 * (l[0] + l[1]), sum(l)][l[0] + l[1] - l[2] >= 0])


s = input()
d1 = int(s.split()[0])
d2 = int(s.split()[1])
d3 = int(s.split()[2])
t = min(d1 * 2 + d3 * 2, d2 * 2 + d3 * 2, d1 + d2 + d3, d2 * 2 + d1 * 2)
print(t)


(d1, d2, d3) = list(map(int, input().split()))
rod1 = d1 + d2 + d3
rod2 = 2 * (d1 + d2)
rod3 = 2 * (d1 + d3)
rod4 = 2 * (d2 + d3)
ans = min(rod1, rod2, rod3, rod4)
print(ans)


(a, b, c) = (int(v) for v in input().split())
print(min(a + b + c, 2 * a + 2 * b, 2 * a + 2 * c, 2 * b + 2 * c))


(d1, d2, d3) = [int(i) for i in input().split()]
s1 = d1 + d2 + d3
s2 = 2 * (d1 + d2)
s3 = 2 * (d1 + d3)
s4 = 2 * (d2 + d3)
output = min(s1, s2, s3, s4)
print(output)


Datos = input('')
Datos = Datos.split()
D1 = int(Datos[0])
D2 = int(Datos[1])
D3 = int(Datos[2])
X1 = D1 + D2 + D3
X2 = D1 * 2 + D2 * 2
X3 = D2 * 2 + D3 * 2
X4 = D1 * 2 + D3 * 2

def Menor(A, B):
	if A < B:
		return A
	else:
		return B
print(Menor(Menor(X1, X2), Menor(X3, X4)))


l = input().split()
a = int(l[0])
b = int(l[1])
c = int(l[2])
ans1 = 2 * (a + b)
if a < b:
	ans2 = min(a + c + b, a + c + c + a)
else:
	ans2 = min(a + c + b, b + c + c + b)
print(min(ans1, ans2))


(n1, n2, n3) = list(map(int, input().split()))
print(min(n1 + n2 + n3, n1 * 2 + n2 * 2, n1 * 2 + n3 * 2, n2 * 2 + n3 * 2))


(x, y, z) = [int(__) for __ in input().strip().split()]
print(min(2 * (x + z), 2 * (y + z), 2 * (x + y), x + y + z))


route = input()
r = []
for x in route.split():
	r.append(int(x))
long = max(r)
m1 = sum(r)
m2 = (sum(r) - long) * 2
if m1 > m2:
	print(m2)
else:
	print(m1)


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


d = sorted([int(i) for i in input().split()])
total = sum(d)
if 2 * (d[0] + d[1]) <= sum(d):
	print(2 * (d[0] + d[1]))
else:
	print(total)


(first, second, con) = map(int, input().split())
road_1 = first + second + con
road_2 = first * 2 + second * 2
road_3 = min(first, second) * 2 + con * 2
print(min(road_1, road_2, road_3))


(d1, d2, d3) = map(int, input().split())
ans = 0
if d2 < d1 + d3:
	ans += d2
else:
	ans += d1 + d3
if d3 < d1 + d2:
	ans += d3
else:
	ans += d1 + d2
if d1 < d2 + d3:
	ans += d1
else:
	ans += d2 + d3
print(ans)


l = list(map(int, input().strip().split()))
(d1, d2, d3) = (l[0], l[1], l[2])
a = 2 * d1 + 2 * d2
b = d1 + d2 + d3
c = d1 + 2 * d3 + d1
d = d2 + 2 * d3 + d2
print(min(a, b, c, d))


from sys import stdin
v1 = 0
v2 = 0
v3 = 0
v4 = 0
v5 = 0
d = [int(x) for x in stdin.readline().split()]
v1 = 2 * d[0] + 2 * d[1]
v2 = 2 * d[0] + 2 * d[2]
v3 = d[0] + d[2] + d[1]
v4 = 2 * d[1] + 2 * d[2]
print(min(v1, v2, v3, v4))


(d1, d2, d3) = list(map(int, input().split()))
l = []
s = d1 + d2 + d3
l.append(s)
c = d1 * 2 + d2 * 2
l.append(c)
e = d1 * 2 + d3 * 2
l.append(e)
r = d2 * 2 + d3 * 2
l.append(r)
print(min(l))


from collections import defaultdict

def mp():
	return map(int, input().split())

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

def pt(x):
	print(x)

def ip():
	return input()

def it():
	return int(input())

def sl(x):
	return [t for t in x]

def spl(x):
	return x.split()

def aj(liste, item):
	liste.append(item)

def bin(x):
	return '{0:b}'.format(x)
(d1, d2, d3) = mp()
print(min([d1 + d2 + d3, 2 * (d1 + d2), 2 * (d1 + d3), 2 * (d2 + d3)]))


(a, b, c) = list(map(int, input().split()))
ans = a + b
ans = min(ans, min(a, b) + c)
ans *= 2
ans = min(ans, a + b + c)
print(ans)


A = input().split()
d1 = int(A[0])
d2 = int(A[1])
d3 = int(A[2])
X = d1 + d2 + d3
Y = 2 * (d1 + d2)
Z = 2 * (min(d1, d2) + d3)
print(min(X, Y, Z))


(d1, d2, d3) = map(int, input().split())
dist = d1 + d2 + d3
dist = min(dist, d1 * 2 + d2 * 2)
dist = min(dist, d1 * 2 + d3 * 2)
dist = min(dist, d2 * 2 + d3 * 2)
print(dist)


from sys import stdin
(d1, d2, d3) = map(int, input().split())
print(min(d1, d2 + d3) + min(d2 + d1, d3) + min(d3 + d1, d2))


def distance(d1, d2, d3):
	a1 = d1 + d2 + d3
	a2 = d1 + d1 + d2 + d2
	a3 = d1 + d3 + d3 + d1
	a4 = d2 + d3 + d3 + d2
	return min(a1, a2, a3, a4)

def main():
	(d1, d2, d3) = map(int, input().split())
	print(distance(d1, d2, d3))
main()


a = list(map(int, input().split()))
if a[0] == a[1] == a[2]:
	print(3 * a[0])
elif a[2] > a[0] + a[1]:
	print(2 * (a[0] + a[1]))
elif a[2] < a[0] or a[2] < a[1]:
	print(2 * (min(a[1], a[0]) + a[2]))
else:
	print(min(a[0], a[1]) + a[2] + max(a[0], a[1]))


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


(d1, d2, d12) = map(int, input().split())
s12 = d1 + d1 + d2 + d2
s23 = d1 + d12 + d2
s34 = d1 + d12 + d12 + d1
s45 = d2 + d12 + d12 + d2
print(min(s12, s23, s34, s45))


(houseToShop1, houseToShop2, shop1ToShop2) = map(int, input().split())
distance = []
distance.append(houseToShop1 + shop1ToShop2 + houseToShop2)
distance.append(houseToShop1 + shop1ToShop2 + shop1ToShop2 + houseToShop1)
distance.append(houseToShop2 + houseToShop2 + houseToShop1 + houseToShop1)
distance.append(houseToShop2 + shop1ToShop2 + shop1ToShop2 + houseToShop2)
print(min(distance))


(a, b, c) = map(int, input().split())
d = 2 * (a + b)
e = 2 * (b + c)
f = 2 * (a + c)
g = a + b + c
print(min(d, e, f, g))


d = input().split()
f = 0
s = False
a = int(d[0])
b = int(d[1])
c = int(d[2])
if a < b:
	f += a
	s = True
else:
	f += b
if a + b < c:
	f += a + b
else:
	f += c
if s:
	if c + a < b:
		f += c + a
	else:
		f += b
elif c + b < a:
	f += c + b
else:
	f += a
print(f)


import time
(x, y, z) = (int(i) for i in input().split())
start = time.time()
print(min(x + y + z, 2 * (x + z), 2 * (y + z), 2 * (x + y)))
finish = time.time()


li = [int(i) for i in input().split()]
d1 = li[0]
d2 = li[1]
d3 = li[2]
t1 = d2 + d2 + d1 + d3 + d2
t2 = d1 + d1 + d2 + d3 + d1
t3 = d1 + d3 + d2
t4 = d1 + d3 + d3 + d1
t5 = d2 + d3 + d3 + d2
t6 = d1 + d1 + d2 + d2
li = [t1, t2, t3, t4, t5, t6]
print(min(li))


a = [int(i) for i in input().split()]
if a[0] < a[1]:
	mini = a[0]
	maxi = a[1]
else:
	maxi = a[0]
	mini = a[1]
c = min(maxi + mini, a[2])
d = min(maxi, a[2] + mini)
print(mini + c + d)


x = [int(x) for x in input().split()]
r1 = x[0] + x[1] + x[2]
r2 = (x[0] + x[1]) * 2
r3 = 2 * (x[0] + x[2])
r4 = 2 * (x[1] + x[2])
print(min(min(r1, r2), min(r3, r4)))


(d1, d2, d3) = input().split()
(d1, d2, d3) = (int(d1), int(d2), int(d3))
print(min(d1 + d2 + d3, 2 * (d1 + d3), 2 * (d2 + d3), 2 * (d1 + d2)))


d = [int(i) for i in input().split()]
i = 0
while i < 2:
	if d[i] > d[i + 1]:
		(d[i], d[i + 1]) = (d[i + 1], d[i])
		i = -1
	i += 1
if 2 * d[0] + 2 * d[1] < d[0] + d[1] + d[2]:
	print(2 * d[0] + 2 * d[1])
else:
	print(d[0] + d[1] + d[2])


(d1, d2, d3) = map(int, input().split())
ans1 = d1 + d2 + d3
ans2 = 2 * (d1 + d2)
ans3 = 2 * (d1 + d3)
ans4 = 2 * (d2 + d3)
print(min(ans1, ans2, ans3, ans4))


(d1, d2, d3) = input().split()
d1 = int(d1)
d2 = int(d2)
d3 = int(d3)
a = d1 + d2 + d3
b = 2 * d1 + 2 * d2
c = 2 * d1 + 2 * d3
d = 2 * d2 + 2 * d3
m = min(a, b, c, d)
print(m)


(first_shop, second_shop, from_first_to_second) = [int(x) for x in input().split()]
if from_first_to_second < first_shop or from_first_to_second < second_shop:
	result = from_first_to_second * 2 + min(first_shop, second_shop) * 2
elif first_shop + second_shop < from_first_to_second:
	result = first_shop * 2 + second_shop * 2
else:
	result = first_shop + second_shop + from_first_to_second
print(result)


l = list(map(int, input().split(' ')))
d1 = l[0]
d2 = l[1]
d3 = l[2]
s1 = d1 + d2 + d3
s2 = d1 * 2 + d2 * 2
s3 = d1 * 3 + d2 + d3
s4 = d1 + d2 * 3 + d3
s5 = d1 * 2 + d3 * 2
s6 = d2 * 2 + d3 * 2
print(min(s1, s2, s3, s4, s5, s6))


lis = list(map(int, input().split()))
if lis[0] + lis[1] <= lis[2]:
	print((lis[0] + lis[1]) * 2)
elif lis[1] + lis[2] <= lis[0]:
	print((lis[1] + lis[2]) * 2)
elif lis[0] + lis[2] <= lis[1]:
	print((lis[0] + lis[2]) * 2)
else:
	print(sum(lis))


(x1, x2, x3) = map(int, input().split(' '))
len_max = max(x1, x2, x3)
len_min = min(x1, x2, x3)
lenx = x1 + x2 + x3 - len_max - len_min
if lenx + len_min >= len_max:
	print(len_max + len_min + lenx)
elif lenx + len_min < len_max:
	print(2 * len_min + 2 * lenx)


import copy
import sys
line = input()
v = [int(x) for x in line.split()]
resp = 2 * v[0] + 2 * v[1]
resp = min(resp, 2 * v[0] + 2 * v[2])
resp = min(resp, 2 * v[1] + 2 * v[2])
resp = min(resp, v[0] + v[1] + v[2])
print(resp)


(d1, d2, d3) = map(int, input().split())
res = []
c1 = d1 + d3 + d2
res.append(c1)
c2 = 2 * d1 + 2 * d3
res.append(c2)
c3 = 2 * d2 + 2 * d1
res.append(c3)
c4 = 2 * d2 + 2 * d3
res.append(c4)
print(sorted(res)[0])


listx = input().split()
listx = [int(i) for i in listx]
listx.sort()
if listx[0] + listx[1] > listx[2]:
	minimum = sum(listx)
else:
	minimum = (listx[0] + listx[1]) * 2
print(minimum)


dList = list(map(int, input().split()))
d1 = dList[0]
d2 = dList[1]
d3 = dList[2]
path1 = 2 * (d1 + d2)
path2 = d1 + d2 + d3
path3 = 2 * (d1 + d3)
path4 = 2 * (d2 + d3)
print(min(path1, path2, path3, path4))


def solve(d1, d2, d3):
	D1 = d1 + d2 + d3
	D2 = 2 * (d1 + d2)
	D3 = 2 * (d1 + d3)
	D4 = 2 * (d2 + d3)
	result = min(D1, min(D2, min(D3, D4)))
	return result
(d1, d2, d3) = input().split()
d1 = int(d1)
d2 = int(d2)
d3 = int(d3)
print(solve(d1, d2, d3))


(d1, d2, d3) = list(map(int, input().split()))
print(min(2 * d1 + 2 * d2, d1 + d2 + d3, 2 * d1 + 2 * d3, 2 * d2 + 2 * d3))


(d1, d2, d3) = map(int, input().split())
r1 = 2 * d1 + 2 * d2
r2 = d1 + d2 + d3
r3 = 2 * (d1 + d3)
r4 = 2 * (d2 + d3)
print(min(r1, r2, r3, r4))


__author__ = 'MoonBall'
import sys
T = 1

def process():
	d = list(map(int, input().split()))
	d[0] = min(d[0], d[1] + d[2])
	d[1] = min(d[1], d[0] + d[2])
	print(min(d[0] + d[0] + d[1] + d[1], d[0] + d[1] + d[2]))
for _ in range(T):
	process()


(d, e, f) = map(int, input().split())
a = [d * 2 + e * 2] + [d + f + e] + [(d + f) * 2] + [(e + f) * 2]
print(min(a))


arr = list(map(int, input().split()))
x = 0
y = sum(arr)
for i in range(3 - 1):
	x += min(arr) * 2
	arr.remove(min(arr))
if y <= x:
	print(y)
else:
	print(x)


import sys
input = sys.stdin.readlines()
input_list = input[0].split(' ')
d1 = int(input_list[0])
d2 = int(input_list[1])
d3 = int(input_list[2])
routes = {'S1': {'A': [d1, 'D'], 'B': [d3, 'S2']}, 'D': {'A': [d1, 'S1'], 'B': [d2, 'S2']}, 'S2': {'A': [d2, 'D'], 'B': [d3, 'S1']}}
possibilities = []
possibilities.append(d1 + d3 + d2)
possibilities.append(d1 + d1 + d2 + d2)
possibilities.append(d2 + d2 + d1 + d1)
possibilities.append(d1 + d3 + d3 + d1)
possibilities.append(d2 + d3 + d3 + d2)
print(min(possibilities))


(D1, D2, D3) = map(int, input().split())
mylist = [None] * 4
mylist[0] = D1 * 2 + D2 * 2
mylist[1] = D1 + D2 + D3
mylist[2] = D1 * 2 + D3 * 2
mylist[3] = D2 * 2 + D3 * 2
mylist.sort()
print(mylist[0])


(a, b, c) = map(int, input().split())
dist = set()
dist.add(a + b + c)
dist.add(2 * (a + b))
dist.add(2 * (a + c))
dist.add(2 * (b + c))
dist = sorted(list(dist))
print(dist[0])


d = list((int(i) for i in input().split()))
print(min(d[0] + d[1] + d[2], d[0] * 2 + d[2] * 2, d[1] * 2 + d[2] * 2, d[0] * 2 + d[1] * 2))


def f(d1, d2, d3):
	return min(d1, d2 + d3) + min(d2, d1 + d3) + min(d3, d1 + d2)
(d1, d2, d3) = map(int, input().split())
print(f(d1, d2, d3))


a = list(input().split(' '))
print(min(int(a[0]) + int(a[1]) + int(a[2]), 2 * (int(a[0]) + int(a[1])), 2 * (int(a[1]) + int(a[2])), 2 * (int(a[0]) + int(a[2]))))


(ha, hb, ab) = map(int, input().split())
a1 = 2 * ha + 2 * hb
b1 = ha + hb + ab
c1 = 2 * ha + 2 * ab
d1 = 2 * hb + 2 * ab
l = [a1, b1, c1, d1]
print(min(l))


(x, y, z) = list(map(int, input().split()))
ans1 = 2 * x + 2 * y
ans2 = x + z + y
ans3 = y + z + y + x
ans4 = y + z + z + y
ans5 = x + z + z + x
print(min(ans1, ans2, ans3, ans4, ans5))


(d1, d2, d3) = (int(i) for i in input().split())
sum = 0
if d1 <= d2:
	sum += d1
	if d3 >= d1 + d2:
		sum += d1 + d2 + d2
	else:
		sum += d3
		if d2 >= d1 + d3:
			sum += d1 + d3
		else:
			sum += d2
else:
	sum += d2
	if d3 >= d1 + d2:
		sum += d2 + d1 + d1
	else:
		sum += d3
		if d1 >= d2 + d3:
			sum += d2 + d3
		else:
			sum += d1
print(sum)


l = list(map(int, input().split()))
if l[0] < l[1]:
	s = l[0] + min(l[2] + min(l[1], l[2] + l[0]), l[0] + 2 * l[1])
else:
	s = l[1] + min(l[2] + min(l[0], l[2] + l[1]), l[1] + 2 * l[0])
print(s)


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
(d1, d2, d3) = map(int, input().split())
htoa = min(d1, d2 + d3)
htob = min(d2, d1 + d3)
atob = min(d3, d1 + d2)
ans = htoa + atob + htob
print(ans)


a = list(map(int, input().split()))
if a[0] + a[1] <= a[2]:
	print((a[0] + a[1]) * 2)
if a[0] + a[1] > a[2]:
	if a[0] <= a[1] and a[1] <= a[2] + a[0]:
		print(a[0] + a[2] + a[1])
	if a[0] <= a[1] and a[1] > a[2] + a[0]:
		print((a[0] + a[2]) * 2)
	if a[0] > a[1] and a[0] <= a[2] + a[1]:
		print(a[1] + a[2] + a[0])
	if a[0] > a[1] and a[0] > a[2] + a[1]:
		print((a[1] + a[2]) * 2)


(d1, d2, d3) = map(int, input().split())
P1 = d1 + d2 + d3
P2 = (d1 + d2) * 2
p3 = (d1 + d3) * 2
p4 = (d2 + d3) * 2
print(min(P1, P2, p3, p4))


(z, x, c) = map(int, input().split())
print(min(z + x + c, z * 2 + x * 2, z * 2 + c * 2, c * 2 + x * 2))


(d1, d2, d3) = list(map(int, input().split()))
res = list()
res.append(d1 + d2 + d3)
res.append(2 * d1 + 2 * d2)
res.append(2 * d1 + 2 * d3)
res.append(2 * d2 + 2 * d3)
print(min(res))


l = []
(d1, d2, d3) = map(int, input().split())
l.append(d1 * 2 + d2 * 2)
l.append(d1 + d2 + d3)
l.append((d1 + d3) * 2)
l.append((d2 + d3) * 2)
print(min(l))


a = list(map(int, input().split()))
print(min(sum(a), 2 * (a[0] + a[1]), 2 * (a[0] + a[2]), 2 * (a[1] + a[2])))


(d1, d2, d3) = list(map(int, input().split()))
w1 = 2 * d1 + 2 * d2
w2 = d1 + d3 + d2
w3 = d1 + d3 + d3 + d1
w4 = d2 + d3 + d3 + d2
print(min(w1, w2, w3, w4))


k = input()
d1 = int(k.split(' ')[0])
d2 = int(k.split(' ')[1])
d3 = int(k.split(' ')[2])
x = 2 * d1 + 2 * d2
y = d1 + d3 + d2
z = d1 * 2 + d3 * 2
h = d2 * 2 + d3 * 2
H = [x, y, z, h]
print(min(H))


(l1, l2, l3) = [int(x) for x in input().split()]
p = []
p.append(l1 + l2 + l3)
p.append(l1 * 2 + l3 * 2)
p.append(l1 * 2 + l2 * 2)
p.append(l3 * 2 + l2 * 2)
print(min(p))


l = [int(i) for i in input().split()]
b = sum(l)
l.sort()
l.pop(-1)
print(min(2 * sum(l), b))


(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
x1 = a + a + b + b
x2 = a + c + b
x3 = a + c + c + a
x4 = b + c + c + b
print(min(x1, min(x2, min(x3, x4))))


d = list(map(int, input().split(' ')))
if max(d) > sum(d) - max(d):
	print(2 * (sum(d) - max(d)))
else:
	print(sum(d))


(A1, A2, A3) = map(int, input().split())
print(min(2 * A1 + 2 * A2, A1 + A2 + A3, 2 * A1 + 2 * A3, 2 * A2 + 2 * A3))


maxn = 100
(d1, d2, d3) = map(int, input().split())
ans = min(min(d1 + d2 + d3, 2 * (d1 + d3)), min(2 * (d1 + d2), 2 * (d2 + d3)))
print(ans)


data = tuple(map(int, input().split()))
s = sum(data)
print(min(s, 2 * (s - max(data))))


l = list(map(int, input().split()))
d1 = l[0]
d2 = l[1]
d3 = l[2]
r = []
p1 = d1 + d3 + d2
r.append(p1)
p2 = 2 * (d1 + d2)
r.append(p2)
p3 = 2 * (d1 + d3)
r.append(p3)
p4 = 2 * (d2 + d3)
r.append(p4)
r.sort()
print(r[0])


l = [int(x) for x in input().split()]
d1 = l[0]
d2 = l[1]
d3 = l[2]
q = []
q.append(2 * (d1 + d2))
q.append(d1 + d3 + d2)
q.append(2 * (d2 + d3))
q.append(2 * (d1 + d3))
print(min(q))


import sys
numbers = list(map(int, input().split()))
variants = []
varaiant_1 = sum(numbers)
variants.append(varaiant_1)
varaiant_2 = numbers[0] * 2 + numbers[1] * 2
variants.append(varaiant_2)
varaiant_3 = numbers[0] * 2 + numbers[2] * 2
variants.append(varaiant_3)
varaiant_4 = numbers[1] * 2 + numbers[2] * 2
variants.append(varaiant_4)
print(min(variants))


(a, b, c) = map(int, input().split())
m = a + b + a + b
n = b + c + c + b
p = a + c + c + a
q = a + c + b
print(min(m, n, p, q))


import sys
a = list(map(int, input().split()))
(d1, d2, d3) = (a[0], a[1], a[2])
print(min(d1 * 2 + d2 * 2, d1 * 2 + d3 * 2, d2 * 2 + d3 * 2, d1 + d3 + d2))


(a, b, c) = [int(i) for i in input().split()]
s = [a + b + c, 2 * (a + c), 2 * (a + b), 2 * (b + c)]
kt = s[0]
for i in range(4):
	if s[i] < kt:
		kt = s[i]
print(kt)


(d1, d2, dn) = map(int, input().split())
a1 = d1 + d1 + d2 + d2
a2 = d1 + d2 + dn
a3 = d2 + d2 + dn + dn
a4 = d1 + d1 + dn + dn
print(min(a1, a2, a3, a4))


(house_to_shop1_dist, house_to_shop2_dist, shop1_to_shop2_dist) = map(int, input().split())
cost1 = house_to_shop1_dist + shop1_to_shop2_dist + house_to_shop2_dist
cost2 = 2 * (house_to_shop1_dist + house_to_shop2_dist)
cost3 = 2 * (house_to_shop1_dist + shop1_to_shop2_dist)
cost4 = 2 * (house_to_shop2_dist + shop1_to_shop2_dist)
print(min(cost1, cost2, cost3, cost4))


import sys
s = sys.stdin.readline().split()
n1 = int(s[0])
n2 = int(s[1])
n3 = int(s[2])
t = [n1, n2, n3]
t.sort()
if t[0] + t[1] < t[2]:
	print(2 * (t[0] + t[1]))
else:
	print(t[0] + t[1] + t[2])


l = list(map(int, input().split()))
ans = 0
if l[0] < l[1]:
	ans += l[0]
	if l[0] + l[1] <= l[2]:
		ans += l[0] + l[1]
		ans += l[1]
	else:
		ans += l[2]
		if l[1] <= l[2] + l[0]:
			ans += l[1]
		else:
			ans += l[2] + l[0]
else:
	ans += l[1]
	if l[1] + l[0] <= l[2]:
		ans += l[1] + l[0]
		ans += l[0]
	else:
		ans += l[2]
		if l[0] <= l[2] + l[1]:
			ans += l[0]
		else:
			ans += l[2] + l[1]
print(str(ans), end='')


(d1, d2, d3) = map(int, input().split())
ans = min(d1, d2)
if d3 <= d1 + d2:
	ans += d3
	if d3 + min(d1, d2) <= max(d1, d2):
		ans += d3 + min(d1, d2)
	else:
		ans += max(d1, d2)
else:
	ans += d1 + d2 + max(d1, d2)
print(ans)


(d1, d2, d3) = list(map(int, input().split()))
path1 = d1 + d2 + d3
path2 = 2 * (d1 + d2)
path3 = 2 * d1 + 2 * d3
path4 = 2 * d2 + 2 * d3
print(min(path1, path2, path3, path4))


(a, b, c) = map(int, input().split())
q = a + b + c
w = a + a + b + b
e = a + a + c + c
r = b + b + c + c
print(min(min(q, w), min(e, r)))


(d1, d2, d3) = list(map(int, input().split()))
pathH1 = min(d1, d2 + d3)
pathH2 = min(d2, d1 + d3)
path12 = min(d3, d1 + d2)
print(pathH1 + path12 + pathH2)


def trial():
	(d1, d2, d3) = list(map(int, input().split()))
	longest = d1 + d2 + d3
	semi_d1 = (d1 + d3) * 2
	semi_d2 = (d2 + d3) * 2
	back = d1 * 2 + d2 * 2
	return print(min([longest, semi_d1, semi_d2, back]))
trial()


(d1, d2, d3) = map(int, input().split(' '))
res = min(d1 + d2 + d3, min(2 * d2 + 2 * d3, min(2 * d1 + 2 * d3, 2 * d1 + 2 * d2)))
print(res)


(a, b, c) = map(int, input().split())
gza1 = min(a, b)
gzaa = max(a, b)
gza2 = min(gzaa, c)
x = 2 * (gza1 + gza2)
print(min(x, a + b + c))


(d1, d2, d3) = input().split()
d1 = int(d1)
d2 = int(d2)
d3 = int(d3)
z = d1 + d2 + d3
if z > 2 * d1 + 2 * d3:
	z = 2 * d1 + 2 * d3
elif z > 2 * d2 + 2 * d3:
	z = 2 * d2 + 2 * d3
elif z > 2 * d1 + 2 * d2:
	z = 2 * d1 + 2 * d2
print(z)


line1 = [int(x) for x in input().split()]
a = line1[0]
b = line1[1]
c = line1[2]
print(min(2 * a + 2 * b, a + b + c, 2 * a + 2 * c, 2 * b + 2 * c))


(d1, d2, d3) = map(int, input().split(None, 3)[:3])
if d1 <= d2:
	print(d1 + min(d1 + d2, d3) + min(d2, d1 + d3))
else:
	print(d2 + min(d1 + d2, d3) + min(d1, d2 + d3))


(d1, d2, d3) = [int(i) for i in input().split()]
a = min(d1, d2 + d3)
b = min(d2, d1 + d3)
c = min(d3, d2 + d1)
print(a + b + c)


a = list(map(int, input().split()))
d1 = a[0]
d2 = a[1]
d3 = a[2]
ans = min(d1 + d2 + d3, 2 * (d1 + d2), 2 * (d2 + d3), 2 * (d3 + d1))
print(ans)


n = list(map(int, input().split()))
result = 0
if n[0] + n[1] < n[2]:
	result = 2 * n[0] + 2 * n[1]
elif n[1] + n[2] < n[0]:
	result = 2 * n[1] + 2 * n[2]
elif n[0] + n[2] < n[1]:
	result = 2 * n[0] + 2 * n[2]
else:
	result = n[0] + n[1] + n[2]
print(result)


(p, q, r) = map(int, input().split())
print(min(p + q + r, 2 * (p + q), 2 * (p + r), 2 * (q + r)))


(a1, a2, b) = map(int, input().split())
x = min(a1, a2)
I = x
SUM = x
x = min(a1 + a2, b)
SUM += x
I = max(a1, a2)
SUM += min(I, b + min(a1, a2))
print(SUM)


(d1, d2, d3) = map(int, input().split())
min_distance = min(d1 + d2 + d3, 2 * (d1 + d2), 2 * (d2 + d3), 2 * (d3 + d1))
print(min_distance)


(d1, d2, d3) = map(int, input().split())
d123 = sum([d1, d2, d3])
ans = d123
for d in [d1, d2, d3]:
	ans = min(ans, (d123 - d) * 2)
print(ans)


def Main():
	(d1, d2, d3) = map(int, input().split())
	ans = d1 + d2 + d3
	if ans > 2 * d1 + 2 * d2:
		ans = 2 * d1 + 2 * d2
	elif ans > 2 * d1 + 2 * d3:
		ans = 2 * d1 + 2 * d3
	elif ans > 2 * d2 + 2 * d3:
		ans = 2 * d2 + 2 * d3
	print(ans)
Main()


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


(d1, d2, d3) = map(int, input().split())
result = min(d1, d2)
if d1 + d2 > d3:
	result = result + d3
else:
	result = result + d1 + d2
if d2 > d1:
	if d1 + d3 > d2:
		result = result + d2
	else:
		result = result + d1 + d3
elif d2 + d3 > d1:
	result = result + d1
else:
	result = result + d2 + d3
print(result)


(x, y, z) = map(int, input().split())
d = list()
d.append(2 * x + 2 * y)
d.append(x + y + z)
d.append(x + z + z + x)
d.append(y + z + z + y)
print(min(d))


a = input().split()
a[0] = int(a[0])
a[2] = int(a[2])
a[1] = int(a[1])
a.sort()
b = (a[0] + a[1]) * 2
c = a[0] + a[1] + a[2]
d = min(b, c)
print(d)


import sys
(d1, d2, d3) = map(int, sys.stdin.readline().split())
suma = 0
if d1 < d2:
	suma += d1
	if d1 + d2 <= d3:
		suma += d1 + 2 * d2
	else:
		suma += d3
		if d3 + d1 <= d2:
			suma += d3 + d1
		else:
			suma += d2
else:
	suma += d2
	if d1 + d2 <= d3:
		suma += d2 + 2 * d1
	else:
		suma += d3
		if d3 + d2 <= d1:
			suma += d3 + d2
		else:
			suma += d1
print(suma)


def MinDistance(x1, x2, x3):
	d1 = 2 * (x1 + x2)
	d2 = 2 * (x2 + x3)
	d3 = 2 * (x1 + x3)
	d4 = x1 + x2 + x3
	return min(d1, d2, d3, d4)
(x1, x2, x3) = map(int, input().split(' '))
print(MinDistance(x1, x2, x3))


a = input().split()
d1 = int(a[0])
d2 = int(a[1])
d3 = int(a[2])
if d1 > d2:
	(d1, d2) = (d2, d1)
z = d1
if d1 + d2 > d3:
	z += d3
else:
	z += d1 + d2
if d2 > d1 + d3:
	z += d1 + d3
else:
	z += d2
print(z)


(d1, d2, d3) = map(int, input().strip().split(' '))
print(min(d1, d2) + min(d1 + d2, d3) + min(max(d1, d2), d3 + min(d1, d2)))


from math import *
import sys, random

def nextInt():
	return int(input())

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

def nextInts():
	return list(map(int, nextStrs()))

def main():
	(a, b, c) = nextInts()
	print(min(a + a + b + b, a + c + b, b + c + a, a + c + c + a, b + c + c + b))
exit(main())


(d1, d2, d3) = map(int, input().split())
x1 = d1 + d3 + d2
x2 = d1 + d3 + d3 + d1
x3 = d2 + d2 + d1 + d1
x4 = d2 + d3 + d3 + d2
print(min(x1, x2, x3, x4))


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


(a, b, c) = map(int, input().split())
d = [a + c + b, 2 * a + 2 * b, 2 * b + 2 * c, 2 * a + 2 * c]
d.sort()
print(d[0])


(x, y, c) = map(int, input().split())
a = []
a.append(2 * x + 2 * y)
a.append(x + c + y)
a.append(2 * x + 2 * c)
a.append(2 * y + 2 * c)
print(min(a))


(a, b, c) = [int(i) for i in input().split()]
x = 2 * (a + b)
y = a + b + c
z = 2 * (a + c)
r = 2 * (b + c)
print(min(x, y, z, r))


n = input()
a = list(n.split())
l1 = (int(a[0]) + int(a[1])) * 2
l2 = int(a[0]) + int(a[1]) + int(a[2])
l3 = (int(a[0]) + int(a[2])) * 2
l4 = (int(a[1]) + int(a[2])) * 2
k = min(l1, l2)
k1 = min(k, l3)
k2 = min(k1, l4)
print(k2)


lst = list(map(int, input().split()))
result = []
result.append(lst[0] + lst[1] + lst[2])
result.append(lst[0] + lst[2] + lst[2] + lst[0])
result.append(lst[0] + lst[0] + lst[1] + lst[1])
result.append(lst[1] + lst[2] + lst[2] + lst[1])
print(min(result))


d = [int(x) for x in input().split()]
if d[0] > d[1]:
	m = d[0]
	d[0] = d[1]
	d[1] = m
total = d[0]
if d[2] > d[0] + d[1]:
	total += d[0] + d[1]
else:
	total += d[2]
if d[1] > d[2] + d[0]:
	total += d[2] + d[0]
else:
	total += d[1]
print(total)


import sys
from math import sqrt, floor
inp = sys.stdin.readline
read = lambda : list(map(int, inp().split()))

def solve():
	(a, b, c) = sorted(read())
	print(min((a + b) * 2, (a + c) * 2, (b + c) * 2, a + b + c))
solve()


def patrick(a, b, c):
	return min(a + b + c, 2 * a + 2 * c, 2 * b + 2 * c, 2 * a + 2 * b)
(A, B, C) = [int(i) for i in input().split()]
print(patrick(A, B, C))


n = input().split()
a = int(n[0])
b = int(n[1])
c = int(n[2])
my_list = []
my_list.append(2 * a + 2 * b)
my_list.append(a + b + c)
my_list.append(2 * a + 2 * c)
my_list.append(2 * b + 2 * c)
print(min(my_list))


(d1, d2, d3) = map(int, input().split())
print(min(d1, d2) + min(d3 + max(d1, d2), d1 + d2 + max(d1, d2), min(d1, d2) + 2 * d3))


d = [int(i) for i in input().split()]
d1 = d[0]
d2 = d[1]
d3 = d[2]
s1 = 2 * (d1 + d2)
s2 = d1 + d2 + d3
s3 = 2 * (d2 + d3)
s4 = 2 * (d1 + d3)
print(min(s1, s2, s3, s4))


(a, b, c) = map(int, input().split())
d1 = a + b + c
d2 = 2 * (a + b)
d3 = 2 * (a + c)
d4 = 2 * (b + c)
print(min(d1, d2, d3, d4))


import math
from fractions import Fraction as frac
MOD = 1000000000.0 + 7

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

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

def solve(case_no):
	(a, b, c) = map(int, input().split())
	print(min(a + c + b, a + c + c + a, a + a + b + b, b + c + c + b))
t = 1
for i in range(1, t + 1):
	solve(i)


(d1, d2, d3) = input().split()
(d1, d2, d3) = (int(d1), int(d2), int(d3))
a = d1 * 2 + d2 * 2
b = d1 + d2 + d3
c = d1 * 2 + d3 * 2
d = d2 * 2 + d3 * 2
A = [a, b, c, d]
Min = min(A)
print(Min)


l = list(map(int, input().split(' ')))
ab = l[0]
bc = l[1]
ac = l[2]
m = min(ab + ac + bc, 2 * (ab + bc), 2 * (bc + ac), 2 * (ab + ac))
print(m)


(a, b, c) = [int(i) for i in input().split()]
s = 0
if a + b > c:
	s += min(a, b) + c
	if max(a, b) < c + min(a, b):
		s += max(a, b)
	else:
		s += c + min(a, b)
else:
	s += min(a, b)
	if min(a, b) + max(a, b) * 2 < c * 2 + min(a, b):
		s += min(a, b) + max(a, b) * 2
	else:
		s += c * 2 + min(a, b)
print(s)


def get_result():
	(d1, d2, d3) = [int(val) for val in input().split()]
	less = min([d1, d2])
	more = max([d1, d2])
	first_option = sum([d1, d2, d3])
	second_option = less * 2 + more * 2
	third_option = less * 2 + d3 * 2
	return min([first_option, second_option, third_option])
print(get_result())


(d1, d2, d3) = map(int, input().split())
mn = [d1 + d2 + d1 + d2, d1 + d3 + d1 + d3, d2 + d3 + d2 + d3, d1 + d3 + d2]
mn.sort()
print(mn[0])


import random
import sys
import os
(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
print(min(min(a + b + c, 2 * (a + b)), min(2 * (a + c), 2 * (b + c))))


(a, b, c) = map(int, input().strip().split())
x = a + b + c
y = 2 * (a + b)
z = 2 * (a + c)
g = 2 * (b + c)
if x >= y:
	t = y
elif x < y:
	t = x
if z >= g:
	s = g
elif z < g:
	s = z
if t >= s:
	print(s)
elif t < s:
	print(t)


x = list(map(int, input().split()))
a = list()
a.append(x[0] + x[1] + x[2])
a.append(2 * (x[0] + x[1]))
a.append(2 * (x[0] + x[2]))
a.append(2 * (x[1] + x[2]))
print(min(a))


def main():
	d = sorted(list(map(int, input().split())))
	mi = min(2 * (d[0] + d[1]), sum(d))
	print(mi)
main()


(d1, d2, d3) = [int(i) for i in input().split(' ')]
print(min(sum((d1, d2), d3), d1 + d1 + d2 + d2, d1 + d3 + d3 + d1, d2 + d3 + d3 + d2))


nums = input().split()
(n, m, a) = [int(x) for x in nums]

def min_distance(n, m, a):
	return min(n + m + a, 2 * (n + m), 2 * (n + a), 2 * (m + a))
print(min_distance(n, m, a))


n = list(map(int, input().split()))
d1 = n[0]
d2 = n[1]
d3 = n[2]
a = d1 + d2 + d3
b = 2 * (d1 + d2)
c = 2 * (d1 + d3)
d = 2 * (d2 + d3)
result = min(a, b, c, d)
print(result)


(d1, d2, d3) = [int(i) for i in input().split()]
distance1 = 2 * d1 + 2 * d2
distance2 = d1 + d2 + d3
distance3 = 2 * (d2 + d3)
distance4 = 2 * (d1 + d3)
print(min([distance1, distance2, distance3, distance4]))


(d1, d2, d3) = map(int, input().split())
p = 2 * d1 + 2 * d2
q = d1 + d3 + d2
r = 2 * d2 + 2 * d3
s = 2 * d1 + 2 * d3
l = [p, q, r, s]
print(min(l))


a = input('')
l = a.split()
l = [int(x, 10) for x in l]
s1 = l[0]
s2 = l[1]
shps = l[2]
minn = min(s1 + s2 + shps, 2 * s1 + 2 * s2, 2 * s1 + 2 * shps, 2 * s2 + 2 * shps)
print(minn)


x = [int(x) for x in input().split()]
if x[0] > x[1] + x[2]:
	print(2 * (x[1] + x[2]))
elif x[1] > x[0] + x[2]:
	print(2 * (x[0] + x[2]))
elif x[2] > x[0] + x[1]:
	print(2 * (x[0] + x[1]))
else:
	print(sum(x))


l = list(map(int, input().split(' ')))
l.sort()
a = l[0]
b = l[1]
c = l[2]
one = a + b + c
two = 2 * (a + b)
print(min(one, two))


import sys
import math
import bisect

def main():
	A = list(map(int, input().split()))
	B = []
	B.append(sum(A))
	B.append(A[0] + A[2] + A[2] + A[0])
	B.append(A[1] + A[2] + A[2] + A[1])
	B.append(A[0] + A[0] + A[1] + A[1])
	print(min(B))
main()


(d1, d2, d3) = input().split()
d1 = int(d1)
d2 = int(d2)
d3 = int(d3)
x = d1 + d3 + d2
y = d1 + d1 + d2 + d2
z = d2 + d3 + d3 + d2
l = d1 + d1 + d3 + d3
print(min(x, y, z, l))


(a, b, c) = input().split()
(a, b, c) = (int(a), int(b), int(c))
if a + b < c:
	print(2 * (a + b))
elif a + c < b:
	print(2 * (a + c))
elif b + c < a:
	print(2 * (b + c))
else:
	print(a + b + c)


(d1, d2, d3) = [int(a) for a in input().split()]
start_a = d1 + min([d1 + d2, d3]) + min([d2, d3 + d1])
start_b = d2 + min([d1 + d2, d3]) + min([d1, d3 + d2])
shortest_path = start_a if start_a < start_b else start_b
print(shortest_path)


(d1, d2, d3) = map(int, input().split())
first_house_first_distance = 0
if d2 + d3 > d1:
	first_house_first_distance += d1
else:
	first_house_first_distance += d2 + d3
if d1 + d2 > d3:
	first_house_first_distance += d3
else:
	first_house_first_distance += d1 + d2
if d3 + d1 > d2:
	first_house_first_distance += d2
else:
	first_house_first_distance += d1 + d2
second_house_first_distance = 0
if d1 + d3 > d2:
	second_house_first_distance += d2
else:
	second_house_first_distance += d1 + d3
if d2 + d1 > d3:
	second_house_first_distance += d3
else:
	second_house_first_distance += d1 + d2
if d3 + d2 > d1:
	second_house_first_distance += d1
else:
	second_house_first_distance += d3 + d2
if second_house_first_distance > first_house_first_distance:
	print(first_house_first_distance)
else:
	print(second_house_first_distance)


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


ls = [int(i) for i in input().split()]
val = max(ls)
tot = 0
br = 1
for i in ls:
	if br == 0 or val != i:
		tot += i
	if val == i:
		br = 0
print(min(sum(ls), 2 * (ls[0] + ls[1]), 2 * tot))


from typing import List

def parse_input() -> List[int]:
	return [int(x) for x in input().split()]

def solve(d1: int, d2: int, d3: int) -> int:
	include_all = d1 + d2 + d3
	exclude_d1 = 2 * d2 + 2 * d3
	exclude_d2 = 2 * d1 + 2 * d3
	exclude_d3 = 2 * d1 + 2 * d2
	return min(include_all, exclude_d1, exclude_d2, exclude_d3)
(d1, d2, d3) = parse_input()
print(solve(d1, d2, d3))


(a, b, c) = map(int, input().split())
x = a + b + c
y = 2 * a + 2 * b
print(min(x, y, 2 * (a + c), 2 * (b + c)))


a = input().split()
(d1, d2, d3) = (int(a[0]), int(a[1]), int(a[2]))
b = d1 + d2 + d3
if (d1 + d2) * 2 < b:
	print((d1 + d2) * 2)
elif (d2 + d3) * 2 < b:
	print((d2 + d3) * 2)
elif (d1 + d3) * 2 < b:
	print((d1 + d3) * 2)
else:
	print(d1 + d2 + d3)


(b1, b2, b3) = input().split()
b1 = int(b1)
b2 = int(b2)
b3 = int(b3)
minimum = 0
if b3 + b1 + b2 > b1 * 2 + b2 * 2:
	minimum = b1 * 2 + b2 * 2
else:
	minimum = b3 + b2 + b1
if minimum > (b1 + b3) * 2:
	minimum = (b1 + b3) * 2
if minimum > (b2 + b3) * 2:
	minimum = (b2 + b3) * 2
print(minimum)


(d1, d2, d3) = map(int, input().split())
minn = d1 + d3 + d2
if 2 * d1 + 2 * d3 < minn:
	minn = 2 * d1 + 2 * d3
if 2 * d1 + 2 * d2 < minn:
	minn = 2 * d1 + 2 * d2
if 2 * d2 + 2 * d3 < minn:
	minn = 2 * d2 + 2 * d3
print(minn)


L = [int(i) for i in input().split()]
L.sort()
if 2 * L[0] + 2 * L[1] <= sum(L):
	print(2 * L[0] + 2 * L[1])
else:
	print(sum(L))


(a, b, c) = map(int, input().split())
s = 2 * a + 2 * b
d = a + b + c
k = 2 * a + 2 * c
n = 2 * b + 2 * c
print(min(s, d, k, n))


l = list(map(int, input().split()))
k = sorted(l)
if l[0] == l[1] == l[2]:
	print(3 * l[1])
elif sum(k) > 2 * (k[1] + k[0]):
	print(2 * (k[1] + k[0]))
else:
	print(sum(k))


entrada = input('')
aux = list(map(int, entrada.split()))
out = '' + repr(min((aux[0] + aux[1]) * 2, aux[0] + aux[1] + aux[2], (aux[1] + aux[2]) * 2, (aux[0] + aux[2]) * 2))
print(out)


(d1, d2, d3) = map(int, input().split())
rez1 = d1 + d2 + d3
rez2 = d1 + d1 + d2 + d2
rez3 = d1 + d3 + d3 + d1
rez4 = d2 + d3 + d3 + d2
print(min(rez1, rez2, rez3, rez4))


(n, m, o) = map(int, input().split())
if n + m < o:
	print(2 * n + 2 * m)
elif n + o < m:
	print(2 * o + 2 * n)
elif m + o < n:
	print(2 * m + 2 * o)
else:
	print(m + n + o)


(d1, d2, d3) = list(map(int, input().split()))
first = 2 * d1 + 2 * d2
second = d1 + d2 + d3
third = 2 * d1 + 2 * d3
fourth = 2 * d2 + 2 * d3
print(min(first, second, third, fourth))


d = map(int, input().split())
d = list(d)
cases = [d[0] + d[2] + d[1], 2 * d[0] + 2 * d[1], 2 * d[0] + 2 * d[2], 2 * d[1] + 2 * d[2]]
print(min(cases))


(d1, d2, d3) = [int(x) for x in input().split()]
minimum = min(d1, d2) + min(d1 + d2, d3) + min(min(d1, d2) + d3, max(d1, d2))
print(minimum)


(d1, d2, d3) = map(int, input().split())
(d1, d2) = (min(d1, d2), max(d1, d2))
k = d1
a = d3 + d2
b = d3 + d3 + d1
c = d1 + d2 + min(d2, d3 + d1)
k += min(a, b, c)
print(k)


from sys import stdout
data = input().split(' ')
x = int(data[0])
y = int(data[1])
z = int(data[2])
a = 2 * x + 2 * z
b = 2 * y + 2 * z
c = 2 * x + 2 * y
d = x + y + z
paths = [a, b, c, d]
paths.sort()
stdout.write(str(paths[0]))


l = list(map(int, input().split()))
d1 = l[0]
d2 = l[1]
d3 = l[2]
x = min(d1, min(d2, d3)) * 2 + (d1 + d2 + d3 - min(d1, min(d2, d3)) - max(d1, max(d2, d3))) * 2
y = d1 + d2 + d3
print(min(x, y))


data = input()
numbers = data.split(' ')
d1 = int(numbers[0])
d2 = int(numbers[1])
d3 = int(numbers[2])
sum1 = 2 * d1 + 2 * d2
sum2 = d1 + d3 + d2
sum3 = 2 * d1 + 2 * d3
sum4 = 2 * d2 + 2 * d3
if sum1 > sum2:
	sum1 = sum2
if sum1 > sum3:
	sum1 = sum3
res = 0
if sum1 < sum4:
	res = sum1
else:
	res = sum4
print(str(res))


(d1, d2, d12) = map(int, input().split())
x1 = (d1 + d2) * 2
x2 = d1 + d2 + d12
x3 = (d1 + d12) * 2
x4 = (d2 + d12) * 2
print(min([x1, x2, x3, x4]))


n = list(map(int, input().split()))
n.sort()
n1 = int(n[0])
n2 = int(n[1])
n3 = int(n[2])
first = n1 + n2 + n1 + n2
second = n1 + n2 + n3
if first <= second:
	print(first)
else:
	print(second)


(d1, d2, d3) = list(map(int, input().split()))
t1 = d1 * 2 + d2 * 2
t2 = d1 + d2 + d3
t3 = d1 * 2 + d3 * 2
t4 = d2 * 2 + d3 * 2
print(min(t1, t2, t3, t4))


(a, b, c) = map(int, input().split())
p = []
p.append(2 * (a + b))
p.append(2 * (b + c))
p.append(2 * (a + c))
p.append(a + b + c)
print(min(p))


(dLeft, dRight, dShops) = [int(i) for i in input().split(' ')]
minD = 2 * dLeft + 2 * dRight
if dLeft + dRight + dShops < minD:
	minD = dLeft + dRight + dShops
if dLeft * 2 + dShops * 2 < minD:
	minD = dLeft * 2 + dShops * 2
if dRight * 2 + dShops * 2 < minD:
	minD = dRight * 2 + dShops * 2
print(minD)


(a, b, c) = map(int, input().split())
z = min(a, b)
y = max(a, b)
d = z * 2 + y * 2
if y <= c:
	e = z + c + y
else:
	e = z + c + c + z
print(min(d, e))


(a, b, c) = map(int, input().split())
cost = 0
routes = [2 * b + 2 * c, a + c + b, 2 * a + 2 * b, 2 * a + 2 * c]
print(min(routes))


(x, y, z) = map(int, input().split())
n1 = x + y + z
n2 = (y + z) * 2
n3 = (x + z) * 2
n4 = (x + y) * 2
print(min(n1, n2, n3, n4))


(d1, d2, d3) = [int(k) for k in input().split(' ')]
print(min(d1 + min(d1 + d2, d3) + min(d2, d1 + d3), d2 + min(d1 + d2, d3) + min(d1, d2 + d3)))


(d1, d2, d3) = map(int, input().split())
route1 = 2 * d1 + 2 * d2
route2 = d1 + d3 + d2
route3 = 2 * d2 + 2 * d3
route4 = 2 * d1 + 2 * d3
print(min(route1, route2, route3, route4))


def main():
	(a, b, c) = map(int, input().split())
	res = min(a + c + b, 2 * (a + b), 2 * (b + c), 2 * (a + c))
	print(res)
main()


import math
from collections import *
import sys
from functools import reduce

def get_ints():
	return map(int, input().strip().split())

def get_list():
	return list(get_ints())

def get_string():
	return list(input().strip().split())

def printxsp(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
UGLYMOD = int(1000000000.0) + 7
SEXYMOD = 998244353
MAXN = int(100000.0)
(a, b, c) = get_ints()
print(min(a + b + c, a + a + b + b, a + c + c + a, b + c + c + b))


roads = input().split()
(d1, d2, d3) = (int(roads[0]), int(roads[1]), int(roads[2]))
(x1, x2, x3, x4) = (d1 + d1 + d2 + d2, d1 + d2 + d3, d1 + d3 + d3 + d1, d2 + d3 + d3 + d2)
var = [x1, x2, x3, x4]
var.sort()
print(var[0])


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


(d1, d2, d3) = map(int, input().split())
P1 = d1 + d1 + d2 + d2
P2 = d1 + d3 + d3 + d1
P3 = d2 + d3 + d3 + d2
P4 = d1 + d3 + d2
print(min(P1, P2, P3, P4))


(a, b, c) = map(int, input().split(' '))
e = a + b + c
f = 2 * (a + b)
g = 2 * (b + c)
h = 2 * (a + c)

def menor(a, b):
	return a if a < b else b
i = menor(e, f)
j = menor(g, h)
print(menor(i, j))


(d_1, d_2, d_3) = list(map(int, input().split()))
print(min(2 * (d_1 + d_2), d_1 + d_2 + d_3, 2 * (d_1 + d_3), 2 * (d_2 + d_3)))


(d1, d2, d3) = [int(i) for i in input().split()]
ans = d2 + min(d3, d2 + d1) + min(d1, d3 + d2)
ans = min(ans, d1 + min(d3, d1 + d2) + min(d2, d3 + d1))
print(ans)


(d1, d2, d3) = list(map(int, input().split()))
op1 = d1 * 2 + d2 * 2
op2 = d1 * 2 + d3 * 2
op3 = d2 * 2 + d3 * 2
op4 = d1 + d2 + d3
print(min(op1, op2, op3, op4))


n = input()
x = n.split()[0]
y = n.split()[1]
z = n.split()[2]
t = [int(x) + int(y) + int(z), 2 * int(x) + 2 * int(y), 2 * int(y) + 2 * int(z), 2 * int(x) + 2 * int(z)]
print(min(t))


def minDistance(d1, d2, d3):
	minDis = d1 + d3 + d2
	currentDis = 2 * d1 + 2 * d2
	if currentDis < minDis:
		minDis = currentDis
	currentDis = 2 * d1 + 2 * d3
	if currentDis < minDis:
		minDis = currentDis
	currentDis = 2 * d3 + 2 * d2
	if currentDis < minDis:
		minDis = currentDis
	return minDis
(d1, d2, d3) = input().split()
(d1, d2, d3) = (int(d1), int(d2), int(d3))
print(minDistance(d1, d2, d3))


a = list(map(int, input().split()))
b = a[:]
x = a.pop(a.index(max(a)))
y = a.pop(a.index(max(a)))
z = a[0]
if z + y > x:
	print(sum(b))
else:
	print((y + z) * 2)


x = list(map(int, input().split()))
print(min(2 * x[0] + 2 * x[1], x[0] + x[1] + x[2], 2 * x[1] + 2 * x[2], 2 * x[0] + 2 * x[2]))


(n, m, k) = map(int, input().split())
print(min(min(n + m + k, m + m + k + k), min(n * 2 + m * 2, n + k + k + n)))


(s1, s2, ss) = [int(x) for x in input().split()]
a = s1 + ss + s2
b = 2 * s1 + 2 * s2
c = 2 * s2 + 2 * ss
d = 2 * s1 + 2 * ss
print(min(a, b, c, d))


(d1, d2, d3) = map(int, input().split())
List = []
List.append(d1 + d2 + d3)
List.append(2 * d1 + 2 * d2)
List.append(2 * d1 + 2 * d3)
List.append(2 * d2 + 2 * d3)
print(min(List))


(a, b, c) = map(int, input().split())
sum = []
sum.append(a + b + c)
sum.append(a * 2 + b * 2)
sum.append(a * 2 + c * 2)
sum.append(b * 2 + c * 2)
print(min(sum))


(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
s1 = a + b + c
s2 = 2 * (a + b)
s3 = 2 * (b + c)
s4 = 2 * (c + a)
print(min(s1, s2, s3, s4))


A = [int(i) for i in input().split()]
print(min(A[0] + A[1] + A[2], 2 * (A[0] + A[1]), 2 * (A[0] + A[2]), 2 * (A[2] + A[1])))


(a, b, c) = list(map(int, input().split(' ')))
result = min(a + b + c, 2 * a + 2 * b, 2 * a + 2 * c, 2 * b + 2 * c)
print(result)


x = list(map(int, input().split()))
t = 0
LEFT = False
if x[0] <= x[1]:
	t += x[0]
	LEFT = True
else:
	t += x[1]
if LEFT:
	t += min(x[0] + 2 * x[1], x[2] + x[1], x[2] * 2 + x[0])
else:
	t += min(x[1] + 2 * x[0], x[2] + x[0], x[2] * 2 + x[1])
print(t)


(a, b, c) = map(int, input().split())
x = []
x.append(a + b + c)
x.append(2 * b + 2 * a)
x.append(2 * a + 2 * c)
x.append(2 * b + 2 * c)
print(min(x))


a = input().split()
b = int(a[0])
c = int(a[1])
d = int(a[2])
v = b + c + d
e = b + b + c + c
t = c + c + d + d
y = b + b + d + d
x = min(v, e, t, y)
print(x)


a = input().split()
d1 = int(a[0])
d2 = int(a[1])
d3 = int(a[2])
b = d1 + d2 + d3
c = 2 * (d1 + d2)
d = 2 * (d2 + d3)
e = 2 * (d1 + d3)
if b <= c and b <= d and (b <= e):
	print(b)
elif c <= b and c <= d and (c <= e):
	print(c)
elif d <= b and d <= c and (d <= e):
	print(d)
else:
	print(e)


(D1, D2, D3) = [int(i) for i in input().split()]
paths = [D1 + D1 + D2 + D2, D1 + D2 + D3, D1 + D3 + D3 + D1, D2 + D3 + D3 + D2]
print(min(paths))


(d1, d2, d3) = map(int, input().split())
a1 = d1 + d2 + d3
a2 = 2 * (d1 + d2)
a3 = 2 * (d1 + d3)
a4 = 2 * (d2 + d3)
print(min(a1, a2, a3, a4))


(d1, d2, d3) = map(int, input().split())
roads = [d1 + d2 + d3, 2 * (d1 + d3), 2 * (d2 + d3), 2 * (d1 + d2)]
print(min(roads))


(d1, d2, d3) = map(int, input().split())
z1 = d1 + d2 + d3
z2 = d1 * 2 + d2 * 2
z3 = d1 * 2 + d3 * 2
z4 = d2 * 2 + d3 * 2
ans = min(z1, z2, z3, z4)
print(ans)


d = [int(x) for x in input().split()]
res = 0
if d[0] < d[1]:
	res = d[0]
	if d[0] + d[1] < d[2]:
		res += d[0] + d[1] + d[1]
	else:
		res += d[2]
		if d[1] < d[2] + d[0]:
			res += d[1]
		else:
			res += d[2] + d[0]
else:
	res = d[1]
	if d[0] + d[1] < d[2]:
		res += d[0] + d[0] + d[1]
	else:
		res += d[2]
		if d[0] < d[2] + d[1]:
			res += d[0]
		else:
			res += d[2] + d[1]
print(res)


def int_put():
	num_list = input('').split()
	return [int(input) for input in num_list]
(d1, d2, d3) = int_put()
int_list = []
r_1 = d1 * 2 + d2 * 2
r_2 = d1 + d2 + d3
r_3 = d1 + d3 * 2 + d1
r_4 = d2 + d3 * 2 + d2
int_list.append(r_1)
int_list.append(r_2)
int_list.append(r_3)
int_list.append(r_4)
int_list.sort()
print(int_list[0])


(d1, d2, d3) = map(int, input().split())
a = min(d1, d2)
s = a
b = max(d1, d2)
if a + b * 2 < d3 + b:
	s = s + a + b * 2
elif d3 + b < d3 * 2 + a:
	s += d3 + b
else:
	s += d3 * 2 + a
print(s)


data = input().split()
d1 = int(data[0])
d2 = int(data[1])
d3 = int(data[2])
lst = [d1, d2, d3]
lst.sort()
if 2 * (lst[0] + lst[1]) <= d1 + d2 + d3:
	min_distance = 2 * (lst[0] + lst[1])
else:
	min_distance = d1 + d2 + d3
print(min_distance)


import math

def main():
	(d1, d2, d3) = map(int, input().split())
	print(min(d1 + d2 + d3, d1 * 2 + d2 * 2, d1 * 2 + d3 * 2, d2 * 2 + d3 * 2))
main()


(a, b, c) = map(int, input().split())
pa1 = a + b + min(a + b, c)
pa2 = (a + c) * 2
pa3 = (b + c) * 2
print(min(pa1, pa2, pa3))


(d1, d2, d3) = map(int, input().split())
c1 = d1 + d3 + d2
c2 = d1 + d3 + d3 + d1
c3 = d2 + d2 + d1 + d1
c4 = d2 + d3 + d3 + d2
print(min(c1, c2, c3, c4))


(d1, d2, d3) = input().split()
d1 = int(d1)
d2 = int(d2)
d3 = int(d3)
t1 = 2 * (d1 + d2)
t2 = 2 * min(d1, d2) + 2 * d3
t3 = d1 + d2 + d3
print(min((min(t1, t2), t3)))


a = sorted(map(int, input().split()))
if a[0] + a[1] > a[2]:
	print(sum(a))
else:
	print(2 * (a[0] + a[1]))


(d1, d2, d3) = map(int, input().split())
dist = 0
dist += min(d1, d2)
if d1 + d2 > d3:
	dist += d3
else:
	dist += d1 + d2
if max(d1, d2) > min(d1, d2) + d3:
	dist += min(d1, d2) + d3
else:
	dist += max(d1, d2)
print(dist)


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


a = input().split()
a = list(map(int, a))
d1 = a[0]
d2 = a[1]
d3 = a[2]
s = min(d1, d2)
s += min(d3, d1 + d2)
s += min(max(d1, d2), min(d1, d2) + d3)
print(s)


a = list(map(int, input().split()))
x = a[0]
y = a[1]
z = a[2]
total = min(x, y + z) + min(x + y, z) + min(x + z, y)
print(total)


t = 1
while t > 0:
	t -= 1
	(d1, d2, d3) = map(int, input().split())
	ans = min(d1 + d3 + d2, d1 + d3 + d3 + d1, d2 + d2 + d1 + d1, d2 + d3 + d3 + d2)
	print(ans)


l = list(map(int, input().split()))
s = sum(l)
ans = min(l[0], s - l[0]) + min(l[2], s - l[2]) + min(l[1], s - l[1])
print(ans)


n = list(map(int, input().split()))
x = n[0] + n[2] + n[1]
y = n[0] + n[2] + n[2] + n[0]
z = n[1] + n[2] + n[2] + n[1]
w = n[0] + n[0] + n[1] + n[1]
print(min(x, y, z, w))


(d1, d2, d3) = map(int, input().split())
m = 2 * (d1 + d2)
n = d1 + d2 + d3
p = 2 * (d2 + d3)
q = 2 * (d1 + d3)
print(min(m, n, p, q))


a = map(int, input().split())
a = list(a)
x = min(a[0], a[1])
d = min(a[0] + a[1], a[2])
e = min(a[0] + a[1] - x, a[2] + x)
print(x + d + e)


(x, y, z) = input().split()
x = int(x)
y = int(y)
z = int(z)
distance = [int(x), int(y), int(z)]
distance.sort()
result = int(x) + int(y) + int(z)
result2 = int(2 * (distance[0] + distance[1]))
print(min(result, result2))


(d1, d2, d3) = [int(y) for y in input().split()]
print(min(d2 + d3, d1) + min(d1 + d3, d2) + min(d1 + d2, d3))


import sys
import os
list1 = list(map(int, sys.stdin.readline().split()))
list1.sort()
d1 = list1[0]
d2 = list1[1]
d3 = list1[2]
if d1 + d2 < d3:
	print(d1 * 2 + d2 * 2)
else:
	print(d1 + d2 + d3)


(d1, d2, d3) = map(int, input().split())
l1 = d1 + d3 + d2
l2 = d1 + d1 + d2 + d2
l3 = d1 + d3 + d3 + d1
l4 = d2 + d3 + d3 + d2
print(min(l1, l2, l3, l4))


s = input()
mylist = [int(x) for x in s.split()]
mylist2 = []
mylist2.append(mylist[0] + mylist[0] + mylist[1] + mylist[1])
mylist2.append(mylist[2] + mylist[2] + mylist[1] + mylist[1])
mylist2.append(mylist[2] + mylist[2] + mylist[0] + mylist[0])
mylist2.append(mylist[0] + mylist[2] + mylist[1])
print(min(mylist2))


numbers = list(map(int, input().split()))
location = 0
distance = min(numbers[0], numbers[1])
location = numbers.index(distance) + 1
distance += min(numbers[2], numbers[0] + numbers[1])
location = 3 - location
distance += min(numbers[location - 1], sum(numbers) - numbers[location - 1])
print(distance)


lengths = tuple(map(int, input().split()))
s = sum(lengths)
result = sum((min(path, s - path) for path in lengths))
print(result)


import math

def test():
	zahlen = input().split()
	nums = list(map(int, zahlen))
	nums.sort()
	if nums[0] == nums[1] and nums[0] == nums[2] or (int(nums[1]) + int(nums[0])) * 2 > nums[0] + nums[1] + nums[2]:
		print(nums[0] + nums[1] + nums[2])
	else:
		print(nums[0] * 2 + nums[1] * 2)
test()


d = list(map(int, input().split()))
su = 0
su += min(d[0], d[1])
su += min(d[0] + d[1], d[2])
su = min(max(d[0], d[1]) + su, 2 * su)
print(su)


import sys
from math import sqrt

def write_to_stdout(res):
	sys.stdout.write('%d\n' % res)

def read_input():
	values = input().rstrip().split()
	return [int(i) for i in values]

def get_answer(values):
	(d1, d2, d3) = values
	return min(d1 + d2 + d3, 2 * (d1 + d2), 2 * (d1 + d3), 2 * (d2 + d3))

def main():
	values = read_input()
	answer = get_answer(values)
	write_to_stdout(answer)
main()


(d1, d2, d3) = map(int, input().split())
td1 = 2 * d1 + 2 * d2
td2 = 2 * d1 + 2 * d3
td3 = d2 + d3 + d1
td4 = 2 * d2 + 2 * d3
l = [td1, td2, td3, td4]
print(min(l))


q = lambda : map(int, input().split())
qi = lambda : int(input())
qs = lambda : input().split()
(a, b, c) = q()
print(min([sum([a, b, c]), 2 * (a + b), 2 * (a + c), 2 * (c + b)]))


(a, b, c) = list(map(int, input().split()))
(w, x, y, z) = (a + b + c, 2 * a + 2 * b, 2 * b + 2 * c, 2 * a + 2 * c)
print(min(w, x, y, z))


(d1, d2, d3) = map(int, input().split())
mi = min(d1, d2)
ma = max(d1, d2)
ans = mi
ans += min(d3, mi + ma)
ans += min(ma, d3 + mi)
print(ans)


roads = list(map(int, input().split()))
way1 = roads[0] + roads[2] + roads[1]
way2 = 2 * roads[0] + 2 * roads[1]
way3 = 2 * roads[0] + 2 * roads[2]
way4 = 2 * roads[1] + 2 * roads[2]
print(min(way1, way2, way3, way4))


x = list(map(int, input().split()))
ans = 0
ans += min(x[0], x[1])
if ans == x[0]:
	jk = min(x[0] + 2 * x[1], x[1] + x[2], 2 * x[2] + x[0])
	if jk == x[0] + 2 * x[1]:
		ans += x[0] + 2 * x[1]
	elif jk == x[1] + x[2]:
		ans += x[1] + x[2]
	else:
		ans += 2 * x[2] + x[0]
else:
	jk = min(x[1] + 2 * x[0], x[0] + x[2], 2 * x[2] + x[1])
	if jk == x[1] + 2 * x[0]:
		ans += x[1] + 2 * x[0]
	elif jk == x[0] + x[2]:
		ans += x[0] + x[2]
	else:
		ans += 2 * x[2] + x[1]
print(ans)


lst = [int(x) for x in input().split()]
ans = lst[0] + lst[1] + lst[2]
ans = min(ans, 2 * lst[0] + 2 * lst[1])
ans = min(ans, 2 * lst[0] + 2 * lst[2])
ans = min(ans, 2 * lst[1] + 2 * lst[2])
print(ans)


s = input()
s = s.split()
for i in range(3):
	s[i] = int(s[i])
d1 = s[0]
d2 = s[1]
d3 = s[2]
if d1 + d2 <= d3:
	print(2 * d1 + 2 * d2)
elif d1 + d3 <= d2:
	print(2 * d1 + 2 * d3)
elif d2 + d3 <= d1:
	print(2 * d2 + 2 * d3)
else:
	print(d1 + d2 + d3)


q = input().split(' ')
a = int(q[0])
b = int(q[1])
c = int(q[2])
if a + c + b <= a + c + c + a and a + c + b <= b + b + a + a and (a + c + b <= b + c + c + b):
	print(a + c + b)
elif a + c + b >= a + c + c + a and a + c + c + a <= b + b + a + a and (a + c + c + a <= b + c + c + b):
	print(a + c + c + a)
elif a + c + b >= b + b + a + a and a + c + c + a >= b + b + a + a and (b + b + a + a <= b + c + c + b):
	print(b + b + a + a)
else:
	print(b + c + c + b)


(a, b, c) = map(int, input().split())
d = a + b + c
e = 2 * (a + b)
f = 2 * (a + c)
g = 2 * (b + c)
x = d
if e < x:
	x = e
if f < x:
	x = f
if g < x:
	x = g
print(x)


(d1, d2, d3) = [int(d1) for d1 in input().split()]
mn = d1 + d2 + d3
if 2 * d1 + 2 * d2 < mn:
	mn = 2 * d1 + 2 * d2
elif 2 * d1 > d3 and 2 * (d2 + d3) < mn:
	mn = 2 * (d2 + d3)
elif 2 * d2 > d3 and 2 * (d1 + d3) < mn:
	mn = 2 * (d1 + d3)
print(mn)


(l1, l2, l3) = map(int, input().split())
ans = []
ans.append(2 * l1 + 2 * l2)
ans.append(2 * l1 + 2 * l3)
ans.append(2 * l2 + 2 * l3)
ans.append(l1 + l2 + l3)
print(min(ans))


(d1, d2, d3) = map(int, input().split())
v1 = 2 * (d1 + d2)
v2 = d1 + d2 + d3
v3 = 2 * (d2 + d3)
v4 = 2 * (d1 + d3)
print(min(v1, v2, v3, v4))


(a, b, c) = map(int, input().split())
n1 = a + b + c
n2 = 2 * (a + b)
n3 = 2 * (b + a)
n4 = 2 * (a + c)
n5 = 2 * (c + b)
if n1 < n2 and n1 < n3 and (n1 < n4) and (n1 < n5):
	print(n1)
elif n2 == n3 and n2 == n4 and (n3 == n4):
	print(n1)
else:
	print(min(n2, n3, n4, n5))


import unittest
import sys

class Shop:

	def __init__(self, test_inputs=None):
		it = iter(test_inputs.split('\n')) if test_inputs else None

		def uinput():
			return next(it) if it else sys.stdin.readline().rstrip()
		self.nums = list(map(int, uinput().split()))

	def calculate(self):
		(d1, d2, d3) = self.nums
		result = min(d1 + d1 + d2 + d2, d1 + d3 + d2, d2 + d3 + d3 + d2, d1 + d3 + d3 + d1)
		return str(result)

class unitTests(unittest.TestCase):

	def test_single_test(self):
		test = '10 20 30'
		d = Shop(test)
		self.assertEqual(d.nums, [10, 20, 30])
		self.assertEqual(Shop(test).calculate(), '60')
		test = '1 1 5'
		self.assertEqual(Shop(test).calculate(), '4')
		test = ''
		test = ''

	def time_limit_test(self, nmax):
		import random
		import timeit
		test = str(nmax) + ' ' + str(nmax) + '\n'
		numnums = [str(i) + ' ' + str(i + 1) for i in range(nmax)]
		test += '\n'.join(numnums) + '\n'
		nums = [random.randint(1, 10000) for i in range(nmax)]
		test += ' '.join(map(str, nums)) + '\n'
		start = timeit.default_timer()
		d = Shop(test)
		calc = timeit.default_timer()
		d.calculate()
		stop = timeit.default_timer()
		print('\nTimelimit Test: ' + '{0:.3f}s (init {1:.3f}s calc {2:.3f}s)'.format(stop - start, calc - start, stop - calc))
sys.setrecursionlimit(100000)
if sys.argv[-1] == '-ut':
	unittest.main(argv=[' '])
sys.stdout.write(Shop().calculate())


(d1, d2, d3) = [int(x) for x in input().split()]
dist = min(d1, d2)
if dist == d1:
	dist += min(d1 + d2 + d2, d3 + d2, d1 + d3 + d3)
else:
	dist += min(d2 + d1 + d1, d3 + d1, d2 + d3 + d3)
print(dist)


from sys import stdin
max_val = int(10000000000000.0)
min_val = int(-10000000000000.0)

def read_int():
	return int(stdin.readline())

def read_ints():
	return [int(x) for x in stdin.readline().split()]

def read_str():
	return input()

def read_strs():
	return [x for x in stdin.readline().split()]
distances = read_ints()
print(min(sum(distances), 2 * (sum(distances) - max(distances))))


d = [int(i) for i in input().split()]
d.sort()
a = sum(d)
b = 2 * (d[0] + d[1])
print(min(a, b))


(d1, d2, d3) = list(map(int, input().split()))
distance = []
if d1 <= d2:
	distance.append(d1)
	if d3 <= d1 + d2:
		distance.append(d3)
	else:
		distance.append(d1 + d2)
	distance.append(min(d3 + d1, d2))
else:
	distance.append(d2)
	if d3 <= d1 + d2:
		distance.append(d3)
	else:
		distance.append(d1 + d2)
	distance.append(min(d2 + d3, d1))
print(sum(distance))


import math
from decimal import *
import sys
from fractions import Fraction
n = list(map(int, input().split()))
a = n[0]
b = n[1]
c = n[2]
ans = min([a + b + c, 2 * a + 2 * b, 2 * a + 2 * c, 2 * b + 2 * c])
print(ans)


(a, b, c) = list(map(int, input().split()))
mas = []
mas.append(a + b + c)
mas.append(a + a + b + b)
mas.append(a + c + c + a)
mas.append(b + c + c + b)
print(min(mas))


(a, b, c) = (int(i) for i in input().split())
r1 = a + b + c
r2 = 2 * (a + b)
r3 = 2 * (a + c)
r4 = 2 * (b + c)
print(min(r1, r2, r3, r4))


(a, b, c) = map(int, input().split())
d = max(max(a, b), c)
if a + b + c - d >= d:
	print(a + b + c)
else:
	print(2 * (a + b + c - d))


(d1, d2, d3) = map(int, input().split())
if d1 <= d2:
	y = d1
	if d1 + d2 < d3:
		y = y + d1 + d2
		if d2 < d3 + d1:
			y = y + d2
		else:
			y = y + d3 + d1
	else:
		y = y + d3
		if d2 < d3 + d1:
			y = y + d2
		else:
			y = y + d3 + d1
else:
	y = d2
	if d1 + d2 < d3:
		y = y + d1 + d2
		if d1 < d2 + d3:
			y = y + d1
		else:
			y = y + d2 + d3
	else:
		y = y + d3
		if d1 < d2 + d3:
			y = y + d1
		else:
			y = y + d2 + d3
print(y)


(d1, d2, d3) = [int(x) for x in input().split()]
s1 = d1 + d1 + d2 + d2
s2 = d1 + d3 + d2
s3 = d1 + d3 + d3 + d1
s4 = d2 + d3 + d3 + d2
print(min(s1, s2, s3, s4))


d = list(map(int, input().split()))
flaga = 0
if d[1] > d[0]:
	flaga = 1
if flaga == 0:
	total = min(d[0], d[1]) + min(d[0] + d[1], d[2]) + min(d[2] + d[1], d[0])
else:
	total = min(d[0], d[1]) + min(d[0] + d[1], d[2]) + min(d[2] + d[0], d[1])
print(total)


i = input()
li = list(i.split(' '))
li = [int(x) for x in li]
a = li[0] * 2 + li[2] * 2
b = li[1] * 2 + li[2] * 2
c = li[0] * 2 + li[1] * 2
d = li[0] + li[1] + li[2]
new = []
new.insert(0, a)
new.insert(1, b)
new.insert(2, c)
new.insert(3, d)
new.sort()
print(new[0])


(d1, d2, d3) = [int(string) for string in input().split()]
print(min(d1 + d2 + d3, 2 * d1 + 2 * d2, 2 * (d1 + d3), 2 * (d2 + d3)))


num = input()
arr = []
counting = 0
for m in range(0, len(num)):
	if num[m] == ' ':
		arr.append(int(num[counting:m]))
		counting = m + 1
	elif m == len(num) - 1:
		arr.append(int(num[counting:len(num)]))
d1_shop1 = arr[0]
d2_shop2 = arr[1]
d3_both_connect = arr[2]
distance = 0
d2 = False
if d1_shop1 > d2_shop2:
	distance += d2_shop2
	d2 = True
else:
	distance += d1_shop1
if d3_both_connect >= d1_shop1 + d2_shop2:
	distance += d1_shop1 + d2_shop2
else:
	distance += d3_both_connect
if d2 is True:
	if d1_shop1 >= d3_both_connect + d2_shop2:
		distance += d3_both_connect + d2_shop2
	else:
		distance += d1_shop1
if d2 is False:
	if d2_shop2 >= d3_both_connect + d1_shop1:
		distance += d3_both_connect + d1_shop1
	else:
		distance += d2_shop2
print(distance)


from sys import stdin
(d1, d2, d3) = map(int, stdin.readline().strip().split())
ans = 0
if d1 >= d2 + d3:
	ans = 2 * (d2 + d3)
elif d2 >= d1 + d3:
	ans = 2 * (d1 + d3)
elif d3 >= d1 + d2:
	ans = 2 * (d1 + d2)
elif d3 < d1 + d2:
	ans = d1 + d3 + d2
print(ans)


(d1, d2, d3) = [int(x) for x in input().split()]
result1 = d1 + d2 + d3
result2 = 2 * d1 + 2 * d2
resutl3 = 2 * d2 + 2 * d3
result4 = 2 * d1 + 2 * d3
print(min(result1, result2, resutl3, result4))


line = input().split()
d1 = int(line[0])
d2 = int(line[1])
d3 = int(line[2])
first = d1 + d2 + d3
second = 2 * d1 + 2 * d2
third = 2 * (d1 + d3)
fourth = 2 * (d2 + d3)
print(min(first, second, third, fourth))


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


(d1, d2, d3) = map(int, input().split())
path = [d1 + d2 + d3, 2 * (d1 + d2), 2 * (d2 + d3), 2 * (d3 + d1)]
print(min(path))


(a, b, c) = map(int, input().split())
p = [2 * (b + c), 2 * (a + b), 2 * (a + c), a + b + c]
p.sort()
print(p[0])


import sys
(a, b, c) = map(int, sys.stdin.readline().split())
l = [2 * (a + c), a + b + c, 2 * (a + b), 2 * (b + c)]
print(min(l))


read = lambda : list(map(int, input().split()))
(d1, d2, d3) = read()
min = min(2 * d1 + 2 * d2, d1 + d2 + d3, 2 * d1 + 2 * d3, 2 * d2 + 2 * d3)
print(min)


d = [int(i) for i in input().split()]
g = 0
if d[0] < d[1]:
	g += d[0]
	l = 1
	x = 0
else:
	g += d[1]
	l = 0
	x = 1
if d[0] + d[1] < d[2]:
	g += d[0] + d[1]
else:
	g += d[2]
if d[l] < d[2] + d[x]:
	g += d[l]
else:
	g += d[2] + d[x]
print(g)


a = list(map(int, input().split()))
if 2 * (sum(a) - max(a)) < sum(a):
	print(2 * (sum(a) - max(a)))
else:
	print(sum(a))


(a, b, s) = map(int, input().split())
print(min(a + b + s, 2 * (a + b), a + s + s + a, b + s + s + b))


def Bitplus():
	n = int(input())
	x = 0
	for i in range(n):
		a = input()
		if '+' in a:
			x += 1
		else:
			x -= 1
	print(x)

def GiftSetidk():
	n = int(input())
	for i in range(n):
		all = input().split(' ')
		x = int(all[0])
		y = int(all[1])
		a = int(all[2])
		b = int(all[3])
		counter = 0
		count = True
		while count:
			if x >= a and y >= b:
				x -= a
				y -= b
				counter += 1
			elif x >= b and y >= a:
				x -= b
				y -= a
				counter += 1
			else:
				count = False
		print(counter)

def Team():
	n = int(input())
	problemcount = 0
	for i in range(n):
		count = 0
		answer = input().split(' ')
		for i in range(len(answer)):
			answer[i] = int(answer[i])
		for i in answer:
			if i == 1:
				count += 1
		if count >= 2:
			problemcount += 1
	print(problemcount)

def NextRound():
	nk = input().split(' ')
	n = int(nk[0])
	k = int(nk[1])
	print(n, k)
	scores = input().split(' ')
	count = 0
	for i in range(n):
		scores[i] = int(scores[i])
	five = scores[k]
	for i in range(n):
		if scores[i] >= five and scores[i] > 0:
			count += 1
	print(count)

def Beautifulmatrix():
	steps = 0
	matrixes = []
	for i in range(5):
		i = [input().split(' ')]
		matrixes += i
	for i in range(5):
		for j in range(5):
			matrixes[i][j] = int(matrixes[i][j])
	for i in range(5):
		for j in range(5):
			if matrixes[i][j] > 0:
				x = j
				y = i
				break
	while x != 2 or y != 2:
		if x > 2:
			x -= 1
			steps += 1
		elif x < 2:
			x += 1
			steps += 1
		elif y > 2:
			y -= 1
			steps += 1
		elif y < 2:
			y += 1
			steps += 1
	print(steps)

def HelpfulMahts():
	s = input().split('+')
	s.sort()
	print('+'.join(s))

def WordCapitalization():
	word = input()
	List = []
	for i in word:
		List.append(i)
	List[0] = List[0].upper()
	s = ''
	for i in List:
		s += i
	print(s)

def Stonesonthetable():
	n = int(input())
	stones = []
	rrg = input()
	counter = 0
	for i in rrg:
		stones.append(i)
	for i in range(n - 1):
		if stones[i] == stones[i + 1]:
			counter += 1
	print(counter)

def BearandBigBrother():
	inpuut = input().split(' ')
	a = int(inpuut[0])
	b = int(inpuut[1])
	year = 0
	while a <= b:
		a *= 3
		b *= 2
		year += 1
	print(year)

def Wrongsubtraction():
	nk = input().split(' ')
	n = int(nk[0])
	k = int(nk[1])
	for i in range(k):
		p = str(n)
		if p[len(p) - 1] == '0':
			n //= 10
		else:
			n -= 1
	print(n)
import string

def Word():
	word = input()
	lower = 0
	upper = 0
	for i in word:
		if i in string.ascii_lowercase:
			lower += 1
		else:
			upper += 1
	if upper > lower:
		word = word.upper()
	else:
		word = word.lower()
	print(word)

def QueueattheSchool():
	nt = input().split(' ')
	n = nt[0]
	t = int(nt[1])
	a = input()
	b = []
	ref = ''
	for i in a:
		b.append(i)
	for k in range(t):
		whre = []
		for i in range(len(b) - 1):
			if b[i] == 'B' and b[i + 1] != 'B':
				whre.insert(0, i)
		for j in whre:
			b.pop(j)
			b.insert(j + 1, 'B')
	for i in b:
		ref += i
	print(ref)

def Nearlyluckynumber():
	n = input()
	if n.count('7') + n.count('4') == 7 or n.count('7') + n.count('4') == 4:
		print('YES')
	else:
		print('NO')

def Translation():
	s = input()
	t = input()
	n = []
	for i in t:
		n.insert(0, i)
	t = ''
	for i in n:
		t += i
	if t == s:
		print('YES')
	else:
		print('NO')

def ANTONandDanik():
	n = int(input())
	s = input()
	A = s.count('A')
	D = s.count('D')
	if A > D:
		print('Anton')
	elif D > A:
		print('Danik')
	else:
		print('Friendship')

def GeorgeandAccomodation():
	n = int(input())
	rooms = 0
	for i in range(n):
		pq = input().split(' ')
		p = int(pq[0])
		q = int(pq[1])
		if q - p >= 2:
			rooms += 1
	print(rooms)

def Magnets():
	n = int(input())
	Rows = []
	groups = 1
	for i in range(n):
		Rows += [input()]
	for i in range(n - 1):
		if Rows[i] != Rows[i + 1]:
			groups += 1
	print(groups)

def InSearcoanEasyProblem():
	n = int(input())
	counter = 0
	s = input().split(' ')
	if '1' in s:
		print('HARD')
	else:
		print('EASY')

def Hulk():
	c = int(input())
	i = 'I'
	s = ''
	it = 'it'
	for i in range(1, c + 1):
		if i == 1:
			s += 'hate '
		elif i % 2 == 0:
			s += 'that I love '
		else:
			s += 'that I hate '
	print(f'I {s}it')

def CalculatingFunctionidk():
	n = int(input())
	c = 0
	for i in range(1, n + 1):
		if i % 2 != 0:
			c -= i
		else:
			c += i
	print(c)

def IWannaBetheGuyidk():
	n = int(input())
	p = input().split(' ')
	q = input().split(' ')
	counter = 0
	for i in range(1, n + 1):
		if str(i) in p or str(i) in q:
			counter += 1
	if counter == n:
		print('I become the guy.')
	else:
		print('Oh, my keyboard!')

def horsesheo():
	n = input().split(' ')
	many = 4
	whatwas = []
	for i in range(len(n)):
		n[i] = int(n[i])
		if n[i] not in whatwas:
			whatwas.append(n[i])
	print(many - len(whatwas))

def ArrivaloftheGeneralidk():
	n = int(input())
	a = input().split(' ')
	max = 0
	minlist = []
	for i in range(n):
		a[i] = int(a[i])
	for i in a:
		if i > max:
			max = i
	maxloc = a.index(max)
	for i in a:
		minlist.insert(0, i)
	min = max
	for i in a:
		if i < min:
			min = i
	minloc = minlist.index(min)
	print(minloc + maxloc)

def UltraFastMathematician():
	first = input()
	second = input()
	s = ''
	for i in range(len(first)):
		if first[i] == '0' and second[i] == '1':
			s += '1'
		elif first[i] == '1' and second[i] == '0':
			s += '1'
		elif first[i] == '0' and second[i] == '0':
			s += '0'
		elif first[i] == '1' and second[i] == '1':
			s += '0'
	print(s)

def Insomniacure():
	klmn = []
	for i in range(4):
		klmn.append(int(input()))
	d = int(input())
	List = []
	if 1 in klmn:
		return d
	for i in range(4):
		mulit = klmn[i]
		while klmn[i] <= d:
			if klmn[i] not in List:
				List.append(klmn[i])
			klmn[i] += mulit
	return len(List)

def AntonandLetters():
	first = input()
	List = []
	for i in first:
		if i not in List and i in string.ascii_lowercase:
			List.append(i)
	print(len(List))

def Pangram():
	n = int(input())
	word = input().lower()
	List = []
	if n >= 26:
		for i in word:
			if i not in List:
				List.append(i)
		if len(List) == 26:
			print('YES')
		else:
			print('NO')
	else:
		print('NO')

def Collectingcoons():
	n = int(input())
	for i in range(n):
		abcd = input().split(' ')
		for i in range(len(abcd)):
			abcd[i] = int(abcd[i])
		d = abcd[3]
		abcd.pop()
		maxi = 0
		for i in abcd:
			if i > maxi:
				maxi = i
		allindexes = [0, 1, 2]
		indexmax = abcd.index(maxi)
		allindexes.pop(indexmax)
		allminus = 0
		for i in allindexes:
			allminus += abcd[indexmax] - abcd[i]
		d -= allminus
		if d % 3 == 0 and d >= 0:
			print('YES')
		else:
			print('NO')

def Brainsphotos():
	nm = input().split(' ')
	colors = []
	for i in range(int(nm[0])):
		colors += input().split(' ')
	for i in colors:
		if i == 'C' or i == 'M' or i == 'Y':
			return '#Color'
	return '#Black&White'

def SerejaandDima():
	n = int(input())
	card = input().split(' ')
	S = 0
	D = 0
	sturn = True
	for i in range(n):
		if int(card[0]) > int(card[len(card) - 1]):
			if sturn:
				S += int(card[0])
				card.pop(0)
				sturn = False
			else:
				D += int(card[0])
				card.pop(0)
				sturn = True
		elif sturn:
			S += int(card[len(card) - 1])
			card.pop(len(card) - 1)
			sturn = False
		else:
			D += int(card[len(card) - 1])
			card.pop(len(card) - 1)
			sturn = True
	print(f'{S} {D}')

def Vanyaandcubes():
	n = int(input())
	counter = 1
	countdodo = 0
	rows = 0
	while n > 0:
		countdodo += counter
		counter += 1
		rows += 1
		n -= countdodo
	if n == 0:
		print(rows)
	else:
		print(rows - 1)

def GennadyandaCarGame():
	card = input()
	cards = input().replace(' ', '')
	for i in card:
		for j in cards:
			if i == j:
				return 'YES'
	return 'NO'

def FafaandhisCompany():
	n = int(input())
	ways = 0
	for i in range(1, n):
		a = n
		a -= i
		if a % i == 0:
			ways += 1
	print(ways)

def Mahmoudandehabandtheevenoddgame():
	n = int(input())
	Mahmoudsturn = True
	Mahmoudlsot = False
	Ehablost = False
	a = 0
	while not Mahmoudlsot and (not Ehablost):
		if Mahmoudsturn:
			if n % 2 == 0 and n >= 2:
				Ehablost = True
			elif n % 2 != 0 and n >= 2:
				a = n - 1
			else:
				Mahmoudlsot = True
		elif n % 2 == 1 and n >= 1:
			Mahmoudlsot = True
		elif n % 2 == 0 and n >= 1:
			a = n - 1
		else:
			Ehablost = False
		n -= a
		if Mahmoudsturn == True:
			Mahmoudsturn = False
		else:
			Mahmoudsturn = True
	if Mahmoudlsot == True:
		print('Ehab')
	else:
		print('Mahmoud')

def FloorNumber():
	t = int(input())
	for i in range(t):
		nx = input().split(' ')
		n = int(nx[0])
		x = int(nx[1])
		aparteements = 2
		floor = 1
		while n > aparteements:
			aparteements += x
			floor += 1
		print(floor)

def VustheCossackandaContest():
	nmk = input().split(' ')
	n = int(nmk[0])
	m = int(nmk[1])
	k = int(nmk[2])
	if n <= m and n <= k:
		print('Yes')
	else:
		print('No')

def NightattheMuseum():
	word = input()
	rotations = 0
	lower = string.ascii_lowercase + string.ascii_lowercase + string.ascii_lowercase
	loc = lower.index('a', 26, 2 * 26)
	for i in word:
		cplus = loc
		cminus = loc
		keep = True
		while keep:
			if i == lower[cplus] or i == lower[cminus]:
				keep = False
			else:
				cplus += 1
				cminus -= 1
				rotations += 1
				loc = lower.index(i, 26, 2 * 26)
	print(rotations)

def OrdinarYnumbers():
	n = int(input())
	for i in range(n):
		k = int(input())
		counter = 0
		for j in range(1, k + 1):
			a = str(j)
			if len(a) == a.count(a[0]):
				counter += 1
		print(counter)

def DieRoll():
	n = input().split(' ')
	y = int(n[0])
	w = int(n[1])
	number = 0
	dec = 6
	if y >= w:
		for i in range(y, 7):
			number += 1
	else:
		for i in range(w, 7):
			number += 1
	if number % 6 == 0:
		number = number // 6
		dec = 1
	elif number % 3 == 0:
		number = number // 3
		dec = 2
	elif number % 2 == 0:
		number = number // 2
		dec = 3
	print(f'{number}/{dec}')

def Borze():
	n = input()
	l = ''
	k = ''
	for i in n:
		if i == '.' and len(l) == 0:
			k += '0'
		else:
			l += i
			if len(l) == 2:
				if l == '-.':
					k += '1'
					l = ''
				else:
					k += '2'
					l = ''
	print(k)

def FairPlayoff():
	n = int(input())
	for i in range(n):
		loser = {}
		winner = {}
		count = 0
		k = input().split(' ')
		if int(k[0]) > int(k[1]):
			loser['one'] = int(k[1])
			winner['two'] = int(k[0])
		else:
			loser['one'] = int(k[0])
			winner['two'] = int(k[1])
		if int(k[2]) > int(k[3]):
			loser['two'] = int(k[3])
			winner['one'] = int(k[2])
		else:
			loser['two'] = int(k[2])
			winner['one'] = int(k[3])
		for i in loser:
			if loser[i] < winner[i]:
				count += 1
		if count >= 2:
			print('YES')
		else:
			print('NO')

def Bustoudaylanbd():
	n = int(input())
	s = []
	rem = -1
	first = True
	ss = ''
	for i in range(n):
		s += input().split('|')
	for i in range(len(s)):
		if s[i] == 'OO' and first:
			rem = i
			s[i] = '++'
			first = False
	for i in range(len(s)):
		if i % 2 == 0:
			ss += s[i] + '|'
		else:
			ss += s[i] + '\n'
	if not first:
		print('YES')
		print(ss)
	else:
		print('NO')

def Maximumincrease():
	n = int(input())
	arraa = input().split(' ')
	for i in range(len(arraa)):
		arraa[i] = int(arraa[i])
	counter = {}
	for i in range(n):
		counter[i] = 0
	count = 0
	last = 0
	for i in arraa:
		if i > last:
			last = i
			counter[count] += 1
		else:
			last = i
			count += 1
			counter[count] += 1
	max = 0
	for i in range(n):
		if counter[i] > max:
			max = counter[i]
	print(max)

def Jugglingletters():
	n = int(input())
	for i in range(n):
		k = int(input())
		s = ''
		map = {}
		possible = True
		for i in range(k):
			s += input()
		for i in s:
			if i not in map:
				map[i] = 1
			else:
				map[i] += 1
		for i in map:
			if map[i] % k != 0:
				possible = False
		if possible:
			print('YES')
		else:
			print('NO')

def Panoramixsprediction():
	nm = input().split(' ')
	n = int(nm[0])
	m = int(nm[1])
	first = True
	for i in range(n + 1, m):
		count = 0
		for j in range(2, i):
			if i % j == 0:
				count += 1
		if count == 0:
			first = False
			break
	if first:
		count = 0
		for j in range(2, m):
			if m % j == 0:
				count += 1
		if count == 0:
			print('YES')
		else:
			print('NO')
	else:
		print('NO')

def ThreepilesofCanides():
	k = int(input())
	for i in range(k):
		n = input().split(' ')
		canides = 0
		for i in n:
			canides += int(i)
		if canides % 2 != 0:
			canides -= 1
		print(canides // 2)

def filename():
	n = int(input())
	name = input()
	more = 0
	map = {}
	map[more] = 0
	count = 0
	for i in name:
		if i == 'x':
			map[more] += 1
		elif map[more] != 0:
			more += 1
			map[more] = 0
	for i in map:
		if map[i] >= 3:
			while map[i] > 2:
				map[i] -= 1
				count += 1
	print(count)

def Football():
	map = {}
	current = 0
	s = input()
	f = s[0]
	map[current] = 0
	check = False
	for i in s:
		if i == f:
			map[current] += 1
		else:
			current += 1
			map[current] = 1
			f = i
	for i in map:
		if map[i] >= 7:
			check = True
	if check:
		print('YES')
	else:
		print('NO')

def CombinationLock1():
	n = int(input())
	fl = input()
	sl = input()
	count = 0
	for i in range(n):
		goup = int(fl[i])
		god = int(fl[i])
		cu = 0
		cd = 0
		keep = True
		while keep:
			if goup + 1 <= 9:
				goup += 1
				cu += 1
			else:
				goup = 0
				cu += 1
			if god - 1 >= 0:
				god -= 1
				cd += 1
			else:
				god = 9
				cd += 1
			if goup == int(sl[i]):
				count += cu
				keep = False
			elif god == int(sl[i]):
				count += cd
				keep = False
	print(count)

def Watermelon():
	n = int(input())
	down = n // 2
	up = n - down
	rge = up
	for i in range(rge):
		if up % 2 == 0 and down % 2 == 0:
			return print('YES')
		elif up + 1 < n and down - 1 > 0:
			up += 1
			down -= 1
		else:
			return print('NO')

def Dominopiling():
	nk = input().split(' ')
	n = int(nk[0])
	k = int(nk[1])
	mnk = n * k
	print(mnk // 2)

def yetanotherBookshelf():
	n = int(input())
	for i in range(n):
		le = int(input())
		K = input().split(' ')
		SK = []
		lili = []
		for i in range(le):
			if i + 1 <= le - 1:
				if K[i] == '1' and K[i + 1] == '1':
					lili.append(i)
		lili.reverse()
		for i in lili:
			K.pop(i)
		coun = 0
		while K.count('1') > 1:
			f = K.index('1')
			K.pop(f)
			K.insert(f + 1, '1')
			f += 1
			if K[f + 1] == '1':
				K.pop(f)
			coun += 1
		print(coun)

def Combinationlockittakestolong():
	n = int(input())
	fl = input()
	sl = input()
	counter = 0
	for i in range(n):
		up = int(fl[i])
		down = int(fl[i])
		while True:
			if up + 1 <= 9:
				up += 1
			else:
				up = 0
			if down - 1 >= 0:
				down -= 1
			else:
				down = 9
			counter += 1
			if up == int(sl) or down == int(sl):
				break

def iwannabetheguytolong():
	n = int(input())
	lvl = input().split(' ')
	lvls = input().split(' ')
	for i in range(1, n + 1):
		if str(i) not in lvl and str(i) not in lvls:
			return print('Oh, my keyboard!')
	return print('I become the guy.')

def giftsettolong():
	n = int(input())
	for i in range(n):
		rb = input().split(' ')
		x = int(rb[0])
		y = int(rb[1])
		a = int(rb[2])
		b = int(rb[3])
		giftset = 0
		while True:
			if x - a >= 0 and y - b >= 0:
				x -= a
				y -= b
				giftset += 1
			elif x - b >= 0 and y - a >= 0:
				x -= b
				y -= a
				giftset += 1
			else:
				break
		print(giftset)

def uniquwbidauctiontime():
	n = int(input())
	for i in range(n):
		k = int(input())
		list = input().split(' ')
		o = -1
		for i in range(k):
			if list.count(list[i]) == 1:
				if o == -1 or list[i] < o:
					o = list[i]
		if o != -1:
			print(list.index(o) + 1)
		else:
			print(o)

def equalizepriceagain():
	n = int(input())
	for i in range(n):
		k = int(input())
		numbers = input().split(' ')
		for i in range(len(numbers)):
			numbers[i] = int(numbers[i])
		total = 0
		for i in numbers:
			total += i
		if total % k == 0:
			print(total // k)
		else:
			while total % k != 0:
				total += 1
			print(total // k)

def shortsubstrings():
	n = int(input())
	for i in range(n):
		s = input()
		laist = []
		for i in range(len(s)):
			if i % 2 != 0 and i != len(s) - 1:
				laist.append(i)
		laist.reverse()
		s = list(s)
		for i in laist:
			s.pop(i)
		sa = ''
		for i in s:
			sa += i
		print(sa)

def policerecruits():
	n = int(input())
	k = input().split(' ')
	officers = 0
	crimes = 0
	for i in k:
		if int(i) == -1:
			if officers == 0:
				crimes += 1
			else:
				officers -= 1
		else:
			officers += int(i)
	print(crimes)

def thenewyear():
	xxx = input().split(' ')
	for i in range(len(xxx)):
		xxx[i] = int(xxx[i])
	xxx.sort()
	way = 0
	way += abs(int(xxx[1]) - int(xxx[0]))
	way += abs(int(xxx[1]) - int(xxx[2]))
	print(way)

def frogjumpingtimelimit():
	n = int(input())
	for i in range(n):
		abk = input().split(' ')
		a = int(abk[0])
		b = int(abk[1])
		k = int(abk[2])
		all = 0
		for i in range(k):
			if i % 2 == 0:
				all += a
			else:
				all -= b
		print(all)

def patrickandshopping():
	d = input().split(' ')
	d3 = 0
	for i in range(len(d)):
		if int(d[i]) > d3:
			d3 = int(d[i])
	d.pop(d.index(str(d3)))
	d1 = int(d[0])
	d2 = int(d[1])
	distance = d1 + d2
	if d3 <= distance:
		distance += d3
	else:
		distance += distance
	print(distance)
patrickandshopping()


n = input().split()
d1 = int(n[0])
d2 = int(n[1])
d3 = int(n[2])
ma = min(d1, d2)
if d1 * 2 + d2 * 2 <= d1 + d2 + d3 and d1 * 2 + d2 * 2 <= ma * 2 + d3 * 2:
	print(d1 * 2 + d2 * 2)
if d1 + d2 + d3 < d1 * 2 + d2 * 2 and d1 + d2 + d3 < ma * 2 + d3 * 2:
	print(d1 + d2 + d3)
if ma * 2 + d3 * 2 < d1 * 2 + d2 * 2 and ma * 2 + d3 * 2 < d1 + d2 + d3:
	print(ma * 2 + d3 * 2)


(a, b, c) = map(int, input().split())
a1 = 2 * a + 2 * b
a2 = 2 * a + 2 * c
a3 = 2 * b + 2 * c
a4 = a + b + c
a1 = min(a1, a2)
a1 = min(a1, a3)
a1 = min(a1, a4)
print(a1)


abc = input().split()
a = int(abc[0])
b = int(abc[1])
c = int(abc[2])
d = a + b + c
e = 2 * (a + b)
g = 2 * (a + c)
h = 2 * (b + c)
f = min(d, e, g, h)
print(f)


rds = list(map(int, input().split()))
vrnts = []
vrnts.append(rds[0] + rds[2] + rds[1])
vrnts.append(2 * rds[0] + 2 * rds[1])
vrnts.append(2 * rds[0] + 2 * rds[2])
vrnts.append(2 * rds[1] + 2 * rds[2])
print(min(vrnts))


(d1, d2, d3) = map(int, input().split())
r1 = 2 * (d1 + d2)
r2 = d1 + d2 + d3
r3 = 2 * (d1 + d3)
r4 = 2 * (d2 + d3)
if r1 < r2:
	temp = r1
else:
	temp = r2
if r3 < temp:
	temp = r3
if r4 < temp:
	temp = r4
print(temp)


def patrick():
	a = list(map(int, input().split()))
	print(min(a[0], a[1]) + min(a[0] + a[1], a[2]) + min(max(a[0], a[1]), a[2] + min(a[0], a[1])))
patrick()


x = list(map(int, input().split()))
x.sort()
if x[0] + x[1] >= x[2]:
	print(sum(x))
else:
	print((x[0] + x[1]) * 2)


d = sorted(map(int, input().split()))
print(min(sum(d), 2 * sum(d[:2])))


lst = list(map(int, input().split()))
a = lst[0]
b = lst[1]
c = lst[2]
route1 = 2 * min(a + b, b + c, c + a)
route2 = a + b + c
print(min(route1, route2))


(d1, d2, d3) = map(int, input().split())
distance1 = min(d1, d2 + d3) + min(d1 + d2, d3) + min(d2, d1 + d3)
distance2 = min(d2, d1 + d3) + min(d1 + d2, d3) + min(d1, d2 + d3)
print(min(distance1, distance2))


__author__ = 'artyom'

def main():
	(d1, d2, d3) = read(3)
	return min(2 * (d1 + d2), 2 * (d1 + d3), 2 * (d2 + d3), d1 + d2 + d3)

def read(mode=1, size=None):
	if mode == 0:
		return input().strip()
	if mode == 1:
		return int(input().strip())
	if mode == 2:
		return input().strip().split()
	if mode == 3:
		return list(map(int, input().strip().split()))
	a = []
	for _ in range(size):
		a.append(read(3))
	return a

def write(s='\n'):
	if s is None:
		s = ''
	if isinstance(s, tuple) or isinstance(s, list):
		s = ' '.join(map(str, s))
	s = str(s)
	print(s, end='\n')
res = main()
write(res)


(a, b, c) = map(int, input().split())
p = a + b + c
q = 2 * a + 2 * b
r = 2 * a + 2 * c
s = 2 * b + 2 * c
print(min(p, q, r, s))


(x, y, z) = map(int, input().split())
a = x + y + z
b = 2 * (x + y)
c = 2 * (x + z)
d = 2 * (y + z)
k = min(a, b, c, d)
print(k)


n = list(map(int, input().split()))
print(min(2 * (n[0] + n[1]), n[0] + n[1] + n[2], 2 * (n[1] + n[2]), 2 * (n[0] + n[2])))


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nlargest, nsmallest, _heapify_max, _heapreplace_max
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as c
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from fractions import Fraction
mod = pow(10, 9) + 7
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
(d1, d2, d3) = sp()
out(min(d1 + d2 + d3, 2 * (d1 + d3), 2 * (d2 + d3), 2 * (d1 + d2)))


(a, b, c) = map(int, input().split())
d = 2 * (a + c + b) - 2 * max(a, b, c)
e = a + b + c
print(min(e, d))


(n, m, b) = [int(a) for a in input().split(' ')]
if n > b:
	(n, b) = (b, n)
if m > b:
	(m, b) = (b, m)
p = n + m
if b - p > 0:
	print(p * 2)
else:
	print(p + b)


(d1, d2, d3) = input().split()
d1 = int(d1)
d2 = int(d2)
d3 = int(d3)
td = 0
if d3 >= d1 + d2:
	td = (d1 + d2) * 2
elif d2 > d1 + d3:
	td = (d1 + d3) * 2
elif d1 > d2 + d3:
	td = (d3 + d2) * 2
else:
	td = d1 + d2 + d3
print(td)


val = list(map(int, input().split(' ')))
val.sort()
k = (val[0] + val[1]) * 2
l = sum(val)
print(min(k, l))


b = input().split()
(d1, d2, d3) = (int(b[0]), int(b[1]), int(b[2]))
print(min(d1 + d2 + d3, d1 + d2 + d2 + d1, d3 + d3 + d1 + d1, d3 + d2 + d2 + d3))


(x, y, z) = list(map(int, input().split()))
dist = 0
if x <= y:
	dist += x
	if z <= x + y:
		dist += z
	else:
		dist += x + y
	if y <= z + x:
		dist += y
	else:
		dist += z + x
	print(dist)
else:
	dist += y
	if z <= x + y:
		dist += z
	else:
		dist += x + y
	if x <= z + y:
		dist += x
	else:
		dist += z + y
	print(dist)


p = input()
p = p.split()
d1 = int(p[0])
d2 = int(p[1])
d3 = int(p[2])
if d3 >= abs(d1 - d2):
	print(min(2 * (d1 + d2), d1 + d2 + d3))
else:
	a = min(d1, d2)
	print(2 * (a + d3))


(a, b, c) = input().split(' ')
a = int(a)
b = int(b)
c = int(c)
x = a + b + c
y = a + a + b + b
t = a + c + c + a
p = b + c + c + b
z = min(x, y, t, p)
print(z)


(d1, d2, d3) = [int(elem) for elem in input().split()]
print(min(d1 * 2 + d2 * 2, d1 + d2 + d3, d1 * 2 + d3 * 2, d2 * 2 + d3 * 2))


(a, b, c) = map(int, input().split())
m1 = 2 * a + 2 * b
m2 = 2 * a + 2 * c
m3 = 2 * b + 2 * c
m4 = a + b + c
print(min(m1, m2, m3, m4))


(d, f, g) = map(int, input().split())
(x, y) = (min(d, f), max(d, f))
z = x
if x + y <= g:
	z += x + y
else:
	z += g
if g + x <= y:
	z += g + x
else:
	z += y
print(z)


(HF, HS, FS) = list(map(int, input().split()))
print(min([HF + FS + HS, HF + FS + FS + HF, HS + FS + FS + HS, HS + HS + HF + HF]))


(a, b, c) = [int(i) for i in input().split()]
n1 = a + a + b + b
n2 = a + c + b
n3 = b + c + c + b
n4 = a + c + c + a
if n1 > n2:
	n1 = n2
if n1 > n3:
	n1 = n3
if n1 > n4:
	n1 = n4
print(n1)


from collections import deque, Counter
import array
from itertools import combinations, permutations
from math import sqrt
import unittest

def read_int():
	return int(input().strip())

def read_int_array():
	return [int(i) for i in input().strip().split(' ')]
(a, b, c) = read_int_array()
x = 0
if a < b:
	x += a
	x += min(c, a + b)
	x += min(b, c + a)
else:
	x += b
	x += min(c, a + b)
	x += min(a, c + b)
print(x)


def func(a):
	x = a[0] + a[2] + a[1]
	y = a[0] + a[2] + a[2] + a[0]
	w = a[1] + a[1] + a[0] + a[0]
	z = a[1] + a[2] + a[2] + a[1]
	print(min(x, y, z, w))
a = list(map(int, input().split()))
func(a)


(a, b, c) = [int(i) for i in input().split()]
p = a + a + b + b
q = a + b + c
r = 2 * (a + c)
s = 2 * (b + c)
print(min(p, q, r, s))


def answer():
	a = input().split()
	a = [int(x) for x in a]
	h_f = a[0]
	h_s = a[1]
	f_s = a[2]
	return min(h_f + f_s + h_s, 2 * (h_f + h_s), h_f + f_s + f_s + h_f, h_s + f_s + f_s + h_s)
print(answer())


A = [int(i) for i in input().split()]
B = [A[0] + A[1] + A[2], 2 * (A[0] + A[1]), 2 * (A[0] + A[2]), 2 * (A[2] + A[1])]
B.sort()
print(B[0])


paths = list(map(int, input().split(' ')))
paths.sort()
way1 = 2 * (paths[1] + paths[0])
way2 = sum(paths)
print(min(way1, way2))


(d1, d2, d3) = map(int, input().split())
s = []
if d1 < d2:
	s.append(d1 + d3 + d2)
	s.append(d1 * 2 + d2 * 2)
	s.append(d1 * 2 + d3 * 2)
else:
	s.append(d1 + d3 + d2)
	s.append(d1 * 2 + d2 * 2)
	s.append(d2 * 2 + d3 * 2)
print(min(s))


(d1, d2, d3) = map(int, input().split())
D = []
D.append(d1 + d2 + d3)
D.append(2 * d1 + 2 * d2)
D.append(2 * d1 + 2 * d3)
D.append(2 * d2 + 2 * d3)
print(min(D))


(d1, d2, d3) = map(int, input().split())
roads = []
roads.append(2 * d1 + 2 * d2)
roads.append(d1 + d2 + d3)
roads.append(2 * d1 + 2 * d3)
roads.append(2 * d2 + 2 * d3)
roads.sort()
print(roads[0])


(a, b, c) = map(int, input().split())
route1 = a + c + b
route2 = a + c + c + a
route3 = b + c + c + b
route4 = a + a + b + b
print(min(route1, route2, route3, route4))


isDebug = False
d = [int(x) for x in input().split()]
s = []
s.append(d[0] + d[1] + d[2])
s.append(d[0] * 2 + d[1] * 2)
s.append((d[0] + d[2]) * 2)
s.append((d[1] + d[2]) * 2)
print(f's={s}') if isDebug else ''
print(min(s))


(d1, d2, d3) = map(int, input().split())
if d1 > d2:
	(d1, d2) = (d2, d1)
k1 = d1 * 2 + d2 * 2
k2 = d1 + d3 + d2
k3 = d1 * 2 + d3 * 2
print(min([k1, k2, k3]))


b = []
(a, a1, a2) = map(int, input().split())
s = a * 2 + a1 * 2
b.append(s)
s1 = a + a1 + a2
b.append(s1)
s2 = a + a2 + a2 + a
b.append(s2)
s3 = a1 + a2 + a2 + a1
b.append(s3)
print(min(b))


x = sorted(list(map(int, input().split())))
print(min(2 * x[0] + 2 * x[1], sum(x)))


(first, second, both) = map(int, input().split(' '))
total = first + second + both
print(min(total, (total - max(first, second, both)) * 2))


(d1, d2, d3) = [int(s) for s in input().split()]
combo1 = d1 + d2 + d3
combo2 = 2 * d1 + 2 * d2
combo3 = 2 * d3 + 2 * d1
combo4 = 2 * d3 + 2 * d2
COMBOS = [combo1, combo2, combo3, combo4]
print(min(COMBOS))


(d1, d2, d3) = map(int, input().split())
summ = 0
if d1 < d2:
	summ += d1
	if d1 + d2 < d3:
		summ = summ + d1 + 2 * d2
	else:
		summ = summ + d3
		if d3 + d1 < d2:
			summ = summ + d3 + d1
		else:
			summ = summ + d2
else:
	summ += d2
	if d2 + d1 < d3:
		summ = summ + d2 + 2 * d1
	else:
		summ = summ + d3
		if d3 + d2 < d1:
			summ = summ + d3 + d2
		else:
			summ = summ + d1
print(summ)


(d1, d2, d3) = map(int, input().split())
l = min(d1, d2)
total = l
h = max(d1, d2)
p = min(l + h, d3)
total += p
p = min(h, d3 + l)
total += p
print(total)


from typing import Iterator, List

def get_num_input() -> Iterator[int]:
	return map(int, input().split())

def main() -> None:
	sides: List[int]
	base: int
	(*sides, base) = sorted(get_num_input())
	total: int = sum(sides)
	print(min(total + base, total * 2))
ONLY_ONCE: bool = True
for _ in range(1 if ONLY_ONCE else int(input())):
	main()


(d1, d2, d3) = [int(i) for i in input().split()]
a1 = d1 + d2 + d3
a2 = d1 * 2 + d2 * 2
a3 = d1 * 2 + d3 * 2
a4 = d2 * 2 + d3 * 2
print(min([a1, a2, a3, a4]))