We have two bottles for holding water.
Bottle 1 can hold up to A milliliters of water, and now it contains B milliliters of water.
Bottle 2 contains C milliliters of water.
We will transfer water from Bottle 2 to Bottle 1 as much as possible.
How much amount of water will remain in Bottle 2?

-----Constraints-----
 - All values in input are integers.
 - 1 \leq B \leq A \leq 20
 - 1 \leq C \leq 20

-----Input-----
Input is given from Standard Input in the following format:
A B C

-----Output-----
Print the integer representing the amount of water, in milliliters, that will remain in Bottle 2.

-----Sample Input-----
6 4 3

-----Sample Output-----
1

We will transfer two milliliters of water from Bottle 2 to Bottle 1, and one milliliter of water will remain in Bottle 2.

Difficulty: EASY

Solutions:
(a, b, c) = [int(_) for _ in input().split()]
print(max(0, c - (a - b)))


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


(a, b, c) = map(int, input().split())
if c - (a - b) > 0:
	print(c - (a - b))
else:
	print(0)


(A, B, C) = map(int, input().split())
print(max(0, C - (A - B)))


(A, B, C) = map(int, input().split())
print(C - A + B if C - A + B >= 0 else '0')


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


(a, b, c) = list(map(int, input().split()))
into_a = a - b
remain_c = c - into_a
if remain_c > 0:
	print(remain_c)
else:
	print(0)


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


N = list(map(int, input().split()))
print(max(0, N[2] - (N[0] - N[1])))


(A, B, C) = [int(i) for i in input().split()]
print(C - min(C, A - B))


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


(a, b, c) = map(int, input().split())
q = a - b
ans = c - q
if ans < 0:
	ans = 0
print(ans)


(a, b, c) = map(int, input().split())
d = c - a + b
print((d > 0) * d or 0)


(A, B, C) = list(map(int, input().split()))
water = A - B
answer = C - water
if answer < 0:
	print(0)
else:
	print(answer)


(A, B, C) = list(map(int, input().split()))
print(C - min(A - B, C))


(x, y, z) = map(int, input().split())
s = x - y
print(max(0, z - s))


import sys
(a, b, c) = map(int, input().split())
print(max(0, c - (a - b)))


a = list(map(int, input().split()))
A = a[0]
B = a[1]
C = a[2]
if C > A - B:
	print(C - A + B)
else:
	print(0)


(a, b, c) = map(int, input().split())
m = c - a + b
if m < 0:
	m = 0
print(m)


(a, b, c) = map(int, input().split())
x = c - a + b
if x < 0:
	x = 0
print(x)


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


(A, B, C) = (int(x) for x in input().split())
print(max(0, C - A + B))


import sys
from io import StringIO
import unittest

class TestClass(unittest.TestCase):

	def assertIO(self, input, output):
		(stdout, stdin) = (sys.stdout, sys.stdin)
		(sys.stdout, sys.stdin) = (StringIO(), StringIO(input))
		resolve()
		sys.stdout.seek(0)
		out = sys.stdout.read()[:-1]
		(sys.stdout, sys.stdin) = (stdout, stdin)
		self.assertEqual(out, output)

	def test_入力例_1(self):
		input = '6 4 3'
		output = '1'
		self.assertIO(input, output)

	def test_入力例_2(self):
		input = '8 3 9'
		output = '4'
		self.assertIO(input, output)

	def test_入力例_3(self):
		input = '12 3 7'
		output = '0'
		self.assertIO(input, output)

def resolve():
	(A, B, C) = list(map(int, input().split()))
	print(max(C - (A - B), 0))

def __starting_point():
	resolve()
__starting_point()


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


p = eval('-' + input().replace(' ', '+'))
print(0 if p < 0 else p)


(a, b, c) = list(map(int, input().split()))
residue = c - (a - b)
if residue < 0:
	residue = 0
print(residue)


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


def resolve():
	(a, b, c) = map(int, input().split())
	print(max(0, c - (a - b)))
resolve()


a = list(map(int, input().split()))
print(max(0, a[2] - (a[0] - a[1])))


def main():
	(a, b, c) = map(int, input().split())
	print(max(0, c - (a - b)))

def __starting_point():
	main()
__starting_point()


(a, b, c) = [int(x) for x in input().split()]
print(max(c - (a - b), 0))


(a, b, c) = [int(s) for s in input().split()]
print(max([0, c - (a - b)]))


(a, b, c) = map(int, input().split())
container1 = a - b
container2 = c - container1
if container2 > 0:
	print(container2)
else:
	print(0)


(A, B, C) = map(int, input().split())
cap = A - B
C -= min(cap, C)
print(C)


(a, b, c) = [int(i) for i in input().split()]
ans = c - (a - b)
ans = ans if ans >= 0 else 0
print(ans)


(a, b, c) = map(int, input().split())
d = c - (a - b)
if d < 0:
	d = 0
print(d)


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


(A, B, C) = map(int, input().split())
D = C - A + B
if D < 0:
	D = 0
print(D)


(a, b, c) = map(int, input().split())
f1 = a - b
f2 = c - f1
if f2 <= 0:
	print('0')
else:
	print(f2)


(A, B, C) = map(int, input().split())
w = C - A + B
if w < 0:
	w = 0
print(w)


(A, B, C) = map(int, input().split())
X = min(C, A - B)
print(C - X)


(A, B, C) = map(int, input().split())
d = A - B
e = max(0, C - d)
print(e)


def atc_136a(input_v: str) -> int:
	ABC = input_v.split(' ')
	A = int(ABC[0])
	B = int(ABC[1])
	C = int(ABC[2])
	D = C - (A - B)
	if D < 0:
		return 0
	else:
		return D
abc = input()
print(atc_136a(abc))


print(max(0, eval('-' + input().replace(' ', '+'))))


H = list(map(int, input().split()))
print(max(H[2] - (H[0] - H[1]), 0))


(p, q, r) = map(int, input().split())
print(max(r - (p - q), 0))


(A, B, C) = map(int, input().split())
R = A - B
print((C - R) * (C > R))


(a, b, c) = map(int, input().split())
x = a - b
r = c - min(x, c)
print(r)


def water(A, B, C):
	result = C - (A - B)
	return max(0, result)
(A, B, C) = list(map(int, input().split()))
print(water(A, B, C))


A = list(map(int, input().split()))
print(max(0, A[2] - (A[0] - A[1])))


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


def main():
	(a, b, c) = list(map(int, input().split()))
	print(0 if a - b >= c else c - (a - b))

def __starting_point():
	main()
__starting_point()


def return_residue(a, b, c):
	residue = c - (a - b)
	return max(0, residue)
(a, b, c) = list(map(int, input().split()))
print(return_residue(a, b, c))


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


(a, b, c) = (int(num) for num in input().split())
print(max(0, b + c - a))


(A, B, C) = map(int, input().split())
d = min(A - B, C)
print(C - d)


(A, B, C) = [int(n) for n in input().split()]
print(max(0, C - (A - B)))


(a, b, c) = map(int, input().split())
print(abs(min(a - b - c, 0)))


(A, B, C) = [int(v) for v in input().split()]
print(max(C - (A - B), 0))


a = -eval(input().replace(' ', '-'))
print((a > 0) * a or 0)


(a, b, c) = map(int, input().split())
x = a - b
y = c - x
if y <= 0:
	print('0')
else:
	print(y)


(A, B, C) = map(int, input().split())
s = C - (A - B)
if s < 0:
	s = 0
print(s)


(A, B, C) = map(int, input().split())
x = min(A - B, C)
print(C - x)


(a, b, c) = list(map(int, input().split()))
d = a - b
e = c - d
if e < 0:
	e = 0
print(e)


(A, B, C) = list(map(int, input().split()))
ans = C - A + B
if ans <= 0:
	print(0)
else:
	print(ans)