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):
import sys
INPUT = sys.stdin.readline

def SORO_INT(): return int(INPUT())
def MULT_INT_LIST(): return list(map(int, INPUT().split()))
def MULT_INT_MAP(): return map(int, INPUT().split())
def SORO_STRING(): return INPUT()
def MULT_STRING(): return INPUT().split()

A,B,C = MULT_INT_LIST()

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

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(c-(a-b) if c-(a-b) >=0 else 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(i) for i in 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(0,C-A+B))

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

Solution (Python):

import sys


def solve(A: int, B: int, C: int):
    print(max(0,B+C-A))



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

if __name__ == '__main__':
    main()

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

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

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())
print(max(0, C - (A - B)))

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

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

print(r)

Solution (Python):


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

print(max(li[2] - (li[0]-li[1]) ,0))

Solution (Python):
ABC = input().split()
A,B,C = [int(s) for s in ABC]
Cup1 = A -B
Cup2 = max(C - Cup1,0)

print("{}".format(Cup2))

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

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

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

Solution (Python):
a, b, c = map(int, input().split())
ans = c - (a - b)
print(max(ans, 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())
if B+C > A:
    print(C-A+B)
else:
    print(0)

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys
import bisect

mod = 10**9+7
sys.setrecursionlimit(mod) 

def LI(): return list(map(int, sys.stdin.readline().split()))

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

Solution (Python):
input = input()
 
list = input.split(" ")
a = list[0]
b = list[1]
c = list[2]
 
amari = (int(a) - int(b))

if amari > int(c):
  result = 0
  print(0)
else:
  print(int(c) - amari)

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())
if B+C>A:print(B+C-A)
else :print("0")

Solution (Python):
inputs=list(map(int, input().split()))
ans = inputs[2] - min(inputs[0]-inputs[1], inputs[2])
print("{}".format(ans))

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

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

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

result = c - (a - b) 

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

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

D = C - ( A - B )

print(max(0,D))

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

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())
d = a - b
e = 0

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

print(e)

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

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

AB = A-B
result = C-AB
if result < 0: result = 0

print(result)

Solution (Python):
def solve(a, b, c):
    return max(0, c-a+b)

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

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

if ans < 0:
 ans = 0

print(ans)

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 = [int(_) for _ in input().split()]
print(C - min(A - B, C))

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

Solution (Python):
import sys

A,B,C = map(int,sys.stdin.readline().split())
print(max(0,C-(A-B)))

Solution (Python):

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

Solution (Python):
"""
 // Author : snape_here - Susanta Mukherjee
 // Date : 27/07/2019

"""
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
else:
    _str = str
    str = lambda x=b"": x if type(x) is bytes else _str(x).encode()

    


from math import ceil,floor,log,sqrt,factorial,pow,pi






  



def ii(): return int(input())
def fi(): return float(input())
def si(): return str(input())
def mi(): return map(int,input().split())
def li(): return list(mi())

def main():
    
    a,b,c=mi()
    ans=c-(a-b)
    if ans<0:
        ans=0 
    print(ans)



BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def _fill(self):
        s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
        self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
        return s

    def read(self):
        if self.buffer.tell():
            return self.buffer.read()
        return os.read(self._fd, os.fstat(self._fd).st_size)

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", b" "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", b"\n"))
    if kwargs.pop("flush", False):
        file.flush()


sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
input = lambda: sys.stdin.readline().rstrip(b"\r\n")



if __name__ == "__main__":
    main()

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

Solution (Python):
tmp = input()
a = int(tmp.split(" ")[0])
b = int(tmp.split(" ")[1])
c = int(tmp.split(" ")[2])

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

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

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

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(C - min(A-B,C))

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

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

Solution (Python):
import math
import fractions
import copy
import numpy as np
def j(q):
    if q==1: print("YES")
    elif q == 0:print("NO")
    exit(0)
rem = pow(10,9)+7
"""
def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")
"""

def ip():
    return int(input())
def iprow():
    return [int(i) for i in input().split()]
def ips():
    return (int(i) for i in input().split())
def printrow(a):
    for i in a:
        print(i)
"""

def combinations(n,r):
    if n<r:return 0
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def permutations(n,r):
    if n<r:return 0
    return math.factorial(n) // math.factorial(n - r)
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)
"""
a,b,c = ips()
if a <b+c:
    print(b+c-a)
else:
    print(0)

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

Solution (Python):
import sys, math, itertools, bisect, copy, re
from collections import Counter, deque, defaultdict






INF = float('inf')
MOD = 10 ** 9 + 7
EPS = 10 ** -7
sys.setrecursionlimit(1000000)








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

Solution (Python):
from heapq import heappush, heappop
from collections import deque
import itertools
from itertools import permutations
import sys
import bisect
sys.setrecursionlimit(10**6)
def MI():
    return map(int,input().split())
def I():
    return int(input())
def LI():
    return [int(i) for i in input().split()]
YN=['Yes','No']
YNeos='YNeos'
GYN=['Yes','trumpet']
mo=10**9+7
imp='IMPOSSIBLE'

a,b,c=MI()
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,B,C = [int(x) for x in 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())
print(max(0,c+b-a))

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

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

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

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

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):
import glob


TOP_PATH = 'C:\\AtCoder'


REL_PATH = 'ABC\\136'


ABS_PATH = TOP_PATH + '\\' + REL_PATH




class Common:

    problem = []
    index = 0

    def initialize(self, path):
        file = open(path)
        self.problem = file.readlines()
        self.index = 0
        return

    def input_data(self):
        try:
            IS_TEST
            return self.problem[self.index]
            self.index += 1
        except NameError:
            return input()

    def resolve(self):
        pass

    def exec_resolve(self):
        try:
            IS_TEST
            for path in glob.glob(ABS_PATH + '/*.txt'):
                self.initialize(path)
                self.resolve()
        except NameError:
            self.resolve()

class A(Common):

    def resolve(self):

        q = [int(i) for i in self.input_data().split()]
        result = q[2] - q[0] +q[1]
        if result < 0:
            print('0')
        else:
            print(str(result))

solver = A()
solver.exec_resolve()

Solution (Python):

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

vari = a - b

ans = c - vari

if ans < 0:
    ans = 0

print(ans)

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

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

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())
if (a-b) > c:
  print(0)
else:
  print(c+b-a)

Solution (Python):
inp = list(map(int, input().strip().split(' ')))

a = inp[0]
b = inp[1]
c = inp[2]

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

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(0)
else:
	print(c-a+b)

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())
if(c-a+b < 0):
	print(0)
else:
	print(c-a+b)

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 - min(C, A - B))

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

print(C - min(C,A-B))

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

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 C - (A - B) >= 0:
	print("{}".format(C - (A - B)))

else:
	print("{}".format(0))

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

nokori = c - (a - b)

print(0 if nokori < 0 else nokori)

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

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

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

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

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

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

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

ans = (c - (a - b))

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

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

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

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

bucket1_all = A
bucket1 = B
bucket2 = C

bucket1_nokori = bucket1_all - bucket1
ans = bucket2 - bucket1_nokori

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

Solution (Python):
a,b,c = list(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(C-(A-B),0))

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

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

Solution (Python):
import os, sys

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

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

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

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

Solution (Python):
import numpy as np

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())
if ( A - B > C ) :
    print ( 0 )
else :
    print (B+C-A)

Solution (Python):
N = input().split()
a = int(N[0])
b = int(N[1])
c = int(N[2])



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

print(remain)

Solution (Python):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 998244353
eps = 10**-7
def inp(): return int(input())
def inpl(): return list(map(int, input().split()))
def inpl_str(): return list(input().split())

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

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

Solution (Python):
a,b,c = (int(i) for i in input().split())
nokori = a-b
ans = c - nokori
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=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):
"""
- https://atcoder.jp/contests/abc136/tasks/abc136_a
- 容器１：now B, max A
- 容器２：now C
- reg:
    - 1≤B≤A≤20
    - 1≤C≤20
"""

a, b, c = map(int, input().split())
cap = a-b
use = min(a-b, c)
ans = c - use
print(ans)

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

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

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

Solution (Python):
ai = lambda: list(map(int,input().split()))
ai_ = lambda: [int(x)-1 for x in input().split()]
 
a,b,c = ai()
print(max(0,c-a+b))

Solution (Python):


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

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

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

Solution (Python):


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

ans = max(C - min(C, A-B), 0)

print(ans)

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

Solution (Python):
A, B, C = map(int, 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, B + C - A))

Solution (Python):
A,B,C = list(map(int, input().strip().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 = map(int, input().split())
d = c - (a - b)
if d >= 0:
	print(d)
else:
  print("0")

Solution (Python):
def main():
    limit, now, c = map(int,input().split())
    can = limit - now
    if c - can < 0:
        print(0)
    else:
        print(c - can)
    
main()

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

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

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

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

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

Solution (Python):
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush
from fractions import gcd
from copy import deepcopy
import math
Mod = 1000000007



def main(): 
    A,B,C = map(int,input().split())
    print(max(C-A+B,0))
if __name__ == "__main__":
    main() 




def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n < 2 is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))):
        if prime[i] == 1:
            for j in range(2*i,n):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n):
        if prime[i] == 1:
            res.append(i)
    return res

class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py

    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

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

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

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())
if(c-a+b > 0):
  print(c-a+b)
else:
  print(0)

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

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

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

Solution (Python):



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

result = c-a+b

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

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

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

print(B+C-A if B+C-A>0 else 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 = list(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()))
a = C - (A -B)
if a <= 0:
  print(0)
else:
  print(a)

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

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

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

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

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

ans=C-(A-B)

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

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

Solution (Python):

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

Solution (Python):
input_data = input().rstrip().split(' ')
a = int(input_data[0])
b = int(input_data[1])
c = int(input_data[2])
if c - (a - b) >= 0:
  print(c - (a - b))
else:
  print(0)

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

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

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

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

Solution (Python):
inp = raw_input("").split(' ')
A = int(inp[0])
B = int(inp[1])
C = int(inp[2])

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

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

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

ato = a - b 
nokori = c - ato

if nokori < 0:
  nokori = 0

print(nokori)

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

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

Solution (Python):
p=input().rstrip().split(' ')
A=int(p[0])-int(p[1])
if A<=0:
    print(int(p[2]))
else:
    if int(p[2])<=A:
        print(0)
    else:
        print(int(p[2])-A)

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

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

a = int(A)
b = int(B)
c = int(C)
if b + c <= a:
  result = 0
else:
  result = b+c-a
 
print(result)

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 = list(map(int, input().split()))
d = c-(a-b)
if d >= 0:
  print(d)
else:
  print(0)

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

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

print(ans)

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

empty_space = a - b

if empty_space <= c:
    print(c - empty_space)
else:
    print(0)

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

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

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

Solution (Python):


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

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

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

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

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

Solution (Python):

s = input()
t =s.split()
a = int(t[0])
b = int(t[1])
c = int(t[2])

answer = max(0,c+b-a)

print(answer)

Solution (Python):
f = lambda : raw_input().rstrip()
f1 = lambda : f().split()
f2 = lambda t : map(t, f1())

def main1():
    A, B, C = f2(int)
    print 0 if B + C <= A else (B + C) - A

def main2():
    n = int(f())
    p = 0
    ans = -1
    while 10**p<n:
        if 10**(p+1) > n:
            ans = ans + n - 10**p + 1
        else:
            ans = ans + 10**(p+1) - 10**p + 1
        p = p + 2
    print ans
    
def main3():
    n = int(f())
    a = f2(int)
    m = 0
    for i in xrange(1,n):
        if a[i] < a[i-1]:
            m = m + 1
  
    print "Yes" if m < 2 else "No"

def main4():
    s = f()
    n = len(s)
    ans = [0]*n
    m = 1
    i = 1
    st = 0
    s = s + ("L" if s[-1]=="R" else "R")
    while i <= n:
        if s[i] != s[i-1]:
            
            j = st if s[i-1]=="L" else i
            
            if m&1:
                ans[j-1] = ans[j-1] + m/2 + (1 if s[i-1] == "R" else 0) 
                ans[j] = ans[j] + m/2 + (1 if s[i-1] == "L" else 0)
            else:
                ans[j-1] =  ans[j-1] + m/2
                ans[j] = ans[j] + m/2
            m = 0
            st = i
        
        i = i + 1
        m = m + 1
    print " ".join(map(str,ans)) 
         
if __name__=="__main__":
    main1()

Solution (Python):

s = input()
t =s.split()
a = int(t[0])
b = int(t[1])
c = int(t[2])
if c+b-a >= 0:
    answer = c+b-a
else:
    answer = 0
print(answer)

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

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

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


H = C-(A-B)

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

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

Solution (Python):

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

print (r)

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

d = A - B
if d < C:
    print(C - d)
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,b+c-a))

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

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

Solution (Python):
from sys import stdin
def ii(): return int(stdin.readline())
def mi(): return map(int, stdin.readline().split())
def li(): return list(mi())
a, b, c=mi()
c+=b-a
print(max(0, c))

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

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

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

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

print(max(B+C-A, 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, B+C-A))

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