Problem:
 Score : 100 points    Problem Statement 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 1 6 4 3      Sample Output 1 1  We will transfer two milliliters of water from Bottle 2 to Bottle 1 , and one milliliter of water will remain in Bottle 2 .       Sample Input 2 8 3 9      Sample Output 2 4       Sample Input 3 12 3 7      Sample Output 3 0

Solution (Python):
if __name__ == "__main__":
    input_str = input()
    splited = input_str.split(' ')
    A = int(splited[0])
    B = int(splited[1])
    C = int(splited[2])

    nokori = C - (A - B)
    if nokori >= 0:
        print(nokori)
    else:
        print('0')

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

res = c -(a - b)
print(res if res > 0 else 0)

Solution (Python):
a, b, c = map(int, input().split())
if a-b <= c:
	print(str(c-(a-b)))
else:
	print(0)

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

Solution (Python):
IN = [int(_) for _ in input().split()]
A = IN[0]
B = IN[1]
C = IN[2]

ANS = C - (A - B)
if ANS < 0:
    ANS = 0
print(ANS)

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

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

Solution (Python):
def main():
    A, B, C = map(int, input().split())
    ans = C - (A - B)

    if ans >= 0:
        print(ans)
    else:
        print(0)

    return


if __name__ == "__main__":
    main()

Solution (Python):
A,B,C = map(int, input().split())
ret = C-(A-B)
print(ret if ret > 0 else 0)

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

print(c-a+b if c-a+b > 0 else 0)

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

Solution (Python):
if __name__ == '__main__':
    a, b, c = tuple([int(e) for e in input().split()])

    d = a - b
    r = max(0, c - d)

    print(r)

Solution (Python):
A, B, C = map(int, input().split(" "))
if (C - (A - B)) >= 0:
    print(C - (A - B))
else:
    print(0)

Solution (Python):
A, B, C = [int(elem) for elem in input().split()]
a = min(A, B + C)
poured = a - B
print(C - poured)

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

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

sa = A - B

if sa == 0:
    print(C)
elif C < sa:
    print(0)
else:
    print(C-sa)

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

d = c-(a-b)
if d < 0:
    d = 0
print(d)

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

d = a-b
c = c-d
if(c<=0):
    print(0)
else:
    print(c)

Solution (Python):
a,b,c=[int(i) for i in input().split()]
if a==b:
  print(c)
  exit()
print(max(0,c-(a-b)))

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

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

if C-A+B < 0:
    print(0)
else:
    print(C-A+B)

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

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

Solution (Python):
ABC = input().split()
A, B, C = int(ABC[0]), int(ABC[1]), int(ABC[2])

available = A - B
if C <= available:
    print(0)
else:
    print(C - available)

Solution (Python):
A,B,C = map(int,input().split())
X = C-(A-B)
if X>0:
    print(X)
else:
    print(0)

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

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

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

ans = int(0)

ans = C - (A - B)

if ans<=0:
    print (0)
else:
    print(ans)

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

tmp = a - b

ans = c - tmp

if ans <= 0:
    print(0)
else:
    print(ans)

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

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

ans = C-(A-B)
if ans <0:
  print(0)
else:
  print(ans)

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

if c <= a - b:
  print(int(0))
else:
  print(int(c - a + b))

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

if b+c <= a:
    ans = 0
else:
    ans = b+c-a

print(ans)

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

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

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

    if (c-(a-b)) <= 0:
        print(0)
    else:
        print(c-(a-b))

if __name__ == "__main__":
    main()

Solution (Python):

"""
Created on Sat Apr 20 20:47:47 2019

@author: Owner
"""

import numpy as np
import sys
import collections
import scipy.misc
import math
from operator import itemgetter
import itertools
import copy
import bisect
import heapq


def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(int(i))
    i += 1
  if n > 1:
    table.append(int(n))
  return table   

def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []
    
def getNearestValueIndex(list, num):
    """
    概要: リストからある値に最も近い値のインデックスを取得する関数
    @param list: データ配列
    @param num: 対象値
    @return 対象値に最も近い値
    """

    
    idx = np.abs(np.asarray(list) - num).argmin()
    return idx

def find_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default

class UnionFind(object):
    def __init__(self, n=1):
        self.par = [i for i in range(n)]
        self.rank = [0 for _ in range(n)]
        self.size = [1 for _ in range(n)]

    def find(self, x):
        """
        x が属するグループを探索
        """
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    def union(self, x, y):
        """
        x と y のグループを結合
        """
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                x, y = y, x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1
            self.par[y] = x
            self.size[x] += self.size[y]

    def is_same(self, x, y):
        """
        x と y が同じグループか否か
        """
        return self.find(x) == self.find(y)

    def get_size(self, x):
        """
        x が属するグループの要素数
        """
        x = self.find(x)
        return self.size[x]
    

"""
N, X = map(int, input().split())

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

P = [0]*N
Y = [0]*N
for n in range(N):
    P[n], Y[n] = map(int, input().split())


dp = np.zeros((N+1, 4,4,4))
    
all(nstr.count(c) for c in '753')


ABT = zip(A, B, totAB)
result = 0

sorted(ABT,key=itemgetter(2))
A, B, totAB = zip(*ABT)
A.sort(reverse=True)


(x >> i) & 1


dp = [np.inf]*N
for n in range(N):
    if n == 0:
        dp[n] = 0
    else:
        for k in range(1,K+1):
            if n-k >= 0:
                dp[n] = min(dp[n], dp[n-k] + abs(h[n]-h[n-k]))
            else:
                break

add = 1 
res = 0
sums = [0]*(len(nums)+1)
for i in range(len(nums)):
    sums[i+1] = sums[i] + nums[i]
for i in range(0, len(nums), 2):
    left = i
    right = min(i+add, len(nums))
    tmp = sums[right] - sums[left]
    res = max(tmp, res)


li, ri = bisect.bisect_left(p_ac, l[i]-1), bisect.bisect_right(p_ac, r[i]-1)    


org_list = [3, 1, 4, 5, 2]
new_list = sorted(org_list)
print(org_list)
print(new_list)




    for h in range(0,H):
        for w in range(0,W):
            if h == 0 and w == 0:
                pass
            elif h == 0:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h-1][W-w]+1)
            elif w == 0:   
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1)
            else:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1, D[H-h-1][W-w]+1, D[H-h][W-w]+2)
            d_max = max(D[H-h-1][W-w-1], d_max)

"""


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

    
def main(): 
    if B+C <= A:
        print(0)
    else:
        print(C-(A-B))
                
                
                
            
            
                

    
if __name__ == '__main__':
    main()

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

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

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

tmp = c - (a - b)

if tmp > 0:
  print(tmp)
else:
  print(0)

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

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

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

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

Solution (Python):
a,b,c =map(int,input().split())
r = c-(a-b)
if r<0:
    print(0)
else:
    print(r)

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

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

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


M = ABC[0] - ABC[1]

SA = ABC[2] - M

if SA < 0:
    print("0")
else:
    print(SA)

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

capa = A - B

calc = C - capa

if calc < 0:
    print('0')
else:
    print(calc)

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

if C-(A-B) > 0:
    print(C-(A-B))
else:
    print(0)

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

X = A - B
if C <= X:
    Y =0
else:
    Y = C - X
print(Y)

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

Solution (Python):
import sys


def main():
    limit, cur, inc = [int(s) for s in sys.stdin.readline().strip().split()]

    diff = limit - cur
    print(max(inc - diff, 0))


main()

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

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

Solution (Python):
A, B, C = map(int, input().split())
ans = C-(A-B);
if(ans > 0):
  print(ans)
else:
  print(0)

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

if c - (a-b)<0:
    print(0)
else:
    print(c - (a-b))

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

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

print(ans)

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

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

Solution (Python):
A, B, C = map(int, input().rstrip().split())

nokori = C-A+B
if nokori < 0:
    nokori = 0
    
print(nokori)

Solution (Python):
import sys


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


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


if __name__ == "__main__":
    main()

Solution (Python):
import numpy as np

A,B,C= map(str,input().split())
A = int(A)
B = int(B)
C = int(C)

if(C-A+B >= 0):
    print(C-A+B)
else:
    print(0)

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

Solution (Python):


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

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

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

if c - (a - b) >= 0:
    print(c - (a - b))
else:
    print(0)

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

ans = c - (a - b)
if ans <= 0:
    ans = 0

print(ans)

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

ans = C - (A - B)
if ans < 0:
    ans = 0
     
print(ans)

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

Solution (Python):
A, B, C = list(map(int, input().split()))
if A - B >= C:
    print(0)
else:
    print(C-(A-B))

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

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

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

Solution (Python):

import numpy as np

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


if __name__=='__main__':
    main()

Solution (Python):
[capacity, offset, addition] = [int(num) for num in input().split()]

if offset + addition > capacity:
    print(addition - (capacity - offset))
else:
    print(0)

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

print(max(0, C - (A - B)))

Solution (Python):
A, B, C = map(int, input().split())
nokori=C-A+B
if nokori<0:
    print("0")
else:
    print(nokori)

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

d=a-b

if c < d:
  e=0
else:
  e=c-d

print(e)

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

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

ans = C - (A - B)

if ans >= 0:
    print(ans)
else:
    print(0)

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

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

print(0 if c-(a-b) <= 0 else c-(a-b))

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

ans = C - (A - B)
if ans < 0:
    ans = 0
print(ans)

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

Solution (Python):
a,b,c = (int(i) for i in input().split())
ans=c-(a-b)
if ans < 0: print(0)
else: print(ans)

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

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

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

Solution (Python):
A, B, C = map(int, input().split())
ret = C - (A - B)
if ret >= 0:
  print(ret)
else:
  print(0)

Solution (Python):

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

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

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

Solution (Python):
a,b,c=map(int, raw_input().split())
if b+c > a:
    print c-(a-b)
else:
    print 0

Solution (Python):


''' 
------------------------
author : iiou16
------------------------
'''

def main():
    A, B, C = list(map(int, input().split()))

    nokori = A - B
    if C > nokori:
        print(C - nokori)
    else:
        print("0")

if __name__ == '__main__':
    main()

Solution (Python):


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

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

if C >= (A-B):
    print(C-(A-B))
else:
    print(0)

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

print(max(0,C-(A-B)))

Solution (Python):
def transfer(a,b,c):

    n = a - b
    m = c - n
    if (m < 0):
        m = 0

    print("%d" %m)

if __name__ == '__main__':
    a = list(map(int,input().split()))

    transfer(a[0],a[1],a[2])

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

Solution (Python):

import sys


def solve(A: int, B: int, C: int):
    remain = A - B
    result = max(0, C - remain)
    print(result)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    C = int(next(tokens))  
    solve(A, B, C)

if __name__ == '__main__':
    main()

Solution (Python):
def solve():
    a, b, c = map(int, input().split())
    return max(c - (a - b), 0)


if __name__ == "__main__":
    print(solve())

Solution (Python):
A, B, C = map(int, input().split())
ans = C - (A - B)
if ans > 0:
    print(ans)
else:
    print(0)

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

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

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

Solution (Python):
A,B,C = map(int,input().split())
ans = C-(A-B)
print(ans) if ans >= 0 else print(0)

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

Solution (Python):
A,B,C = map(int,input().split(" "))
check = C - (A - B)
if check < 0:
    print(0)
else:
    print(check)

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

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

if c-(a-b)>=0:
        print(c-(a-b))
else:
        print(0)

Solution (Python):
a,b,c = map(int, input().split())
nokori = a - b
answer = c - nokori
if answer < 0:
    print(0)
else:
    print(answer)

Solution (Python):
k=list(map(int,input().split()))
a = int(k[0])
b = int(k[1])
c = int(k[2])
if(c > (a - b)):
   print(c -(a-b))
else:
   print(0)

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

if C < (A-B):
	print(0)
else:
	print(C-(A-B))

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

print(max(0,C-(A-B)))

Solution (Python):


import sys

debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]


    token = lines[0].split(" ")
    a = int(token[0])
    b = int(token[1])
    c = int(token[2])

    return (a, b, c)


def solve(a, b, c):


    

    return max(0, c - (a -b))


def main():
    

    print("%s" % solve(*parse_input()))

if __name__ == '__main__':

    main()

Solution (Python):

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

ans = a[2]-(a[0]-a[1])

if ans < 0:
  print("0")
else:
  print(ans)

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

Solution (Python):


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

ans = c - (a - b)
if ans < 0:
    ans = 0

print(ans)

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

if a - b > c:
    print(0)
else:
    print(c - (a - b))

Solution (Python):
A, B, C = map(int, input().split())
x = A - B - C
if x >= 0:
  print(0)
else:
  print(abs(x))

Solution (Python):
A, B, C = map(int,input().split())
if C - (A - B) >= 0:
  print(C - (A - B))
else:
  print(0)

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

if A >= B + C:
    print(0)
else:
    print(B + C - A)

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

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

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

print(ans)

Solution (Python):
A, B, C = map(int, input().split())
if C-(A-B) > 0:
    print (C-(A-B))
else:
    print(0)

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

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

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

ans = 0
if C < A - B:
    ans = 0
else:
    ans = C - (A - B)

print(ans)

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

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

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

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

d = c - a + b

if d >= 0:
    print(d)

else:
    print(0)

Solution (Python):
A, B, C = (int(_) for _ in input().split())
if (A - B) <= C:
    print(C -(A - B))
else:
    print(0)

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

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

print(max(0,C-(A-B)))

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

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

val = A - B
answer = C - val

if answer < 0:
  answer = 0

print(answer)

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

if (a-b) >= c:
    print(0)
else:
    print(c-(a-b))

Solution (Python):
if __name__ == '__main__':
    a, b, c = map(int, input().split())
    rest = c - (a - b)
    if rest <= 0:
        print(0)
    else:
        print(rest)

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

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

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

if ans<0:
    ans=0
    
print(ans)

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

if A >=(B+C):
	print(0)
else:
	print(C-(A-B))

Solution (Python):
import sys, math
from collections import deque

readline = sys.stdin.readline

A, B, C = map(int, readline().split())

print(max(0, C - (A - B)))

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

Solution (Python):
import sys


A, B, C = [int(v) for v in sys.stdin.readline().split()]
r = A - B
c = max(C - r, 0)

print(c)

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

out = c-(a-b)

if out <=0:
    print(0)
else:
    print(out)

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

Solution (Python):
from sys import stdin

if __name__ == '__main__':
    A, B, C = [int(x) for x in stdin.readline().rstrip().split()]
    print( max( C - ( A - B ), 0 ) )

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

ans = 0

if a < b+c:
  ans = c-(a-b)

print(ans)

Solution (Python):
A,B,C=map(int,input().split())
ANS=C-(A-B)
if ANS<0:
  print(0)
else:
  print(ANS)

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

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

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

Solution (Python):
n1, n2, n3 = [int(i) for i in input().split()]

r1 = n3 -(n1 - n2)

if r1 < 0:
    r1 = 0
print(r1)

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

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

Solution (Python):
import sys

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

d = c-(a-b)

if d >= 0:
    print(d)
else:
    print(0)

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

Solution (Python):
def main():
    A,B,C = map(int,input().split())

    ans = C-(A-B)
    if ans <= 0:
        ans = 0

    print(ans)


if __name__ == '__main__' :
    main()

Solution (Python):
a, b ,c = [int(i) for i in input().split()]
d = b+c-a
if d>0:
    print(d)
else:
    print(0)

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

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

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

if (B + C) < A:
    print(0)
else:
    print(C-(A-B))

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


rest = (a - b)

print(max(c - rest, 0))

Solution (Python):


import os
import sys

A, B, C = map(lambda x: int(x), input().split(" "))







print(max(C-(A-B),0))

Solution (Python):

A, B, C = map(int, input().split())
D=A-B 
E =min(C,D)
ans =C-E
print(ans)

Solution (Python):
(A, B, C) = tuple([int(s) for s in input().split(' ')])
print(max(0, C - A + B))

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

if c-(a-b) < 0:
  print('0')
else:
  print(c-(a-b))

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

if A-B>C:
    print(0)
else:
    print(C-(A-B))

Solution (Python):
A,B,C = map(int,input().split())
if C-(A-B) >= 0:
    print(C-(A-B))
else:
    print(0)

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

Solution (Python):
a, b, c = [int(e) for e in input().split()]
if a - b > c:
  print(0)
else:
  print(c - (a - b))

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

C -= (A - B)
if C < 0 :
    print('0')
else :
    print(C)

Solution (Python):
a,b,c = input().split()
a,b,c =	int(a),	int(b),int(c)
rest = a-b
ans = c-rest
if ans>0:
    print(str(ans))
else:
    print("0")

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

D=A-B
ans=C-D
if ans < 0:
    print("0")
else:
    print(ans)

Solution (Python):

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

Solution (Python):
def main():
    a, b, c = map(int, input().split())
    amari = a - b
    c -= amari
    print(0 if c < 0 else c)


if __name__ == '__main__':
    main()

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

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

Solution (Python):
A, B, C = [int(x) for x in input().split()]
print(str(max(C-(A-B),0)))

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

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

Solution (Python):
A, B, C = map(int, input().split())
answer = C - (A - B)
if answer >= 0:
    print(answer)
else:
    print(0)

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

Solution (Python):
import sys
a, b, c = [int(i) for i in sys.stdin.readline().split()]
r = c - (a - b)
if r <= 0:
    print(0)
else:
    print(r)

Solution (Python):

A, B, C = map(int, input().split())

ans = C - (A - B)
if ans > 0:
    print(ans)
else:
    print(0)

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

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

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

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




if __name__ == '__main__':
  main()

Solution (Python):

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

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

if(C-(A-B)<0):
    print('0')
else:
    print(C-(A-B))

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

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

print(c-(a-b) if c-a+b>=0 else 0)

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

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

dif = c-a+b


if dif >= 0:
  print(dif)
else:
  print(0)

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

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

ans = C - (A - B)
if ans > 0:
    print(ans)
else:
    print(0)

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

x = A - B

print(max(C - x, 0))

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

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

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

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

Solution (Python):

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

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

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

Solution (Python):
a=([int(n) for n in input().split()])
print(max(a[2]-a[0]+a[1],0))

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

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

Volume = C - A + B
if Volume < 0:
    Volume = 0 
print(Volume)

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

if a-b < c:
    print(c-(a-b))
else:
    print(0)

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

Solution (Python):
a, b, c = map(int, input().split())
temp = a - b
ans = c -temp
if ans < 0:
  ans = 0

print(ans)

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

if A-B >= C:
  print(0)
else:
  print(C- A + B)

Solution (Python):
"""


 = sys.stdin.readline().rstrip()
 = list(sys.stdin.readline().rstrip())


 = int(sys.stdin.readline())
 = map(int, sys.stdin.readline().split())
 = list(map(int, sys.stdin.readline().split()))
 = [list(map(int,list(sys.stdin.readline().split()))) for i in range(h)]  


a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654


char_list = list("abcd") 
"""

import math
import sys
import itertools
import queue
from fractions import gcd

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

mod = 1000000007

if __name__ == "__main__":
    a,b,c = map(int, sys.stdin.readline().split())
    if a >= b+c:
        print(0)
    else:
        print(c-(a-b))

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

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

if(b+c-a>=0):
  print(b+c-a)
else:
  print(0)

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

result = c - (a - b)

if result < 0:
  print(0)

else:
  print(result)

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

noko=a-b

an=c-noko

if an<0:
    print(0)
if an>=0:
    print(an)

Solution (Python):
a, b, c = list(map(int, input().split() ))
if b + c <= a:
	ans = 0
else:
	ans = c - (a-b)
print(ans)

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

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

Solution (Python):
from sys import stdin

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

input = lambda: stdin.readline()
main()

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

x = C - (A - B)

if x < 0:
  print(0)
else:
  print(x)

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

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

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

Solution (Python):



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

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

x = c - (a - b)
if x < 0:
    x = 0

print(x)

Solution (Python):
A,B,C = [int(i) for i in input().split()]
ans = C- (A-B) 
print(ans if ans >= 0 else 0)

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

if B+C <= A:
    print("0")
else:
    print(C-(A-B))

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

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

Solution (Python):
import sys,heapq,math,resource
from collections import deque,defaultdict
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
DBG = True 
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

def setrlim():
  sys.setrecursionlimit(250000)
  soft,hard = resource.getrlimit(RLIMIT_STACK)
  
  

a,b,c = inm()
print(c-min(c,a-b))