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

hoge = A-B
C -= hoge

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

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

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

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

main()

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

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

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

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

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

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

Solution (Python):
import sys

input = sys.stdin.readline


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


if __name__ == "__main__":
    main()

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


main()

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

Solution (Python):
def main(a, b, c):
    ans = c - (a - b)
    if ans < 0:
        return 0
    return ans


if __name__ == '__main__':
    i = list(map(int, input().split()))
    a, b, c = i[0], i[1], i[2]
    print(main(a, b, c))

Solution (Python):

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

Solution (Python):
a,b,c = map(int,input().split())
tmp = c-(a-b)
if tmp >0 :
	print("%d" % tmp)
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(c-(a-b),0))

Solution (Python):
import sys

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

Solution (Python):

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

Solution (Python):
import sys
import collections
import copy
input = sys.stdin.readline
A,B,C = map(int,input().split())
print(max(0,B+C-A))

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

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


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

Solution (Python):


import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline 



a,b,c = [int(i) for i in readline().split()]


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

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

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

Solution (Python):
import sys
MAX_INT = int(10e9)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

A,B,C = IL()
tmp = A-B

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

Solution (Python):

import itertools
import sys
import math
from functools import lru_cache





from queue import Queue
from operator import mul
from functools import reduce
from queue import Queue
from operator import mul
from functools import reduce
from functools import lru_cache

input = sys.stdin.readline


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










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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
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 II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

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

Solution (Python):
L1, now1, now2 = map(int, input().split())

if L1-now1 > now2: print("0")
else: print(now2 - (L1-now1))

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(int, input().split()))

n = c-(a-b)

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

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

Solution (Python):
import sys
input = sys.stdin.readline
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(max(C-A+B,0))

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 = (int (i) for i in input().split())
if C - (A - B) > 0:
    ans = C - (A - B)
else:
    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())
s=c-(a-b)
if(s<=0):
    s=0
print(s)

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

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

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):
from fractions import gcd
import math

mod = 998244353

def inverse(a):
    return pow(a, mod - 2, mod)


def usearch(x, a):
    lft = 0
    rgt = len(a) + 1
    while rgt - lft > 1:
        mid = (rgt + lft) // 2
        if a[mid] <= x:
            lft = mid
        else:
            rgt = mid
    return lft

def S(x1, y1, x2, y2, x3, y3):
    return heron(math.sqrt((x1 - x2)**2 + (y1 - y2)**2), math.sqrt((x1 - x3)**2 + (y1 - y3)**2), math.sqrt((x3 - x2)**2 + (y3 - y2)**2))

def heron(a, b, c):
    try:
        d = (a + b + c) / 2
        return round(math.sqrt(d * (d - a) * (d - b) * (d - c)) * 2)
    except Exception as e:
        return 0

def main():
    a, b, c = map(int, input().split())
    a -= b
    c -= a
    print(max(0, c))
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(C-min(A-B, C))

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

if a[1]+a[2]>a[0]:
    print(a[1]+a[2]-a[0])
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(int(max(B-A+C,0)))

Solution (Python):
if __name__ == '__main__':
    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())
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())
a -= b
c -= a
if c < 0:
	c = 0
print(c)

Solution (Python):
def transfer(A: int, B: int, C: int)->int:
    return C - min(A-B, C)


if __name__ == "__main__":
    A, B, C = map(int, input().split())

    ans = transfer(A, B, C)
    print(ans)

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

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

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

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

Solution (Python):
def main():
    import sys
    import copy
    input = sys.stdin.readline
 
    a, b, c = [int(i) for i in input().split()]
    
    out = c - (a - b)
    
    if out < 0 :
        out = 0
        
    print(out)

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

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

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

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


from collections import deque
import itertools as ite
import sys
import math

sys.setrecursionlimit(1000000)

INF = 10 ** 18
MOD = 10 ** 9 + 7

A, B, C = map(int, raw_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(C - (A - B), 0))

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
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(c - min(a-b, c))

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 = list(map(int, input().split()))

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

Solution (Python):
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)

def s(generator, splitter, mapper):
    return [ mapper(s) for s in generator().split(splitter) ]


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]

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

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

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

Solution (Python):

import sys


def solve(A: int, B: int, C: int):
    print(max(C - (A - B), 0))
    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):
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(0)
else:
    print(c - (a-b))

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

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

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

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

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

Solution (Python):
import sys
def get_array(): return list(map(int , sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()
a,b,c=get_ints()
if (a-b)>=c:
  print(0)
else:
  print(c-(a-b))

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

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

Solution (Python):
from sys import stdin
A,B,C = [int(x) for x in stdin.readline().rstrip().split()]
ans = (B + C - A)
print(max(ans,0))

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

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

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

Solution (Python):
import numpy as np
import math
import sys
sys.setrecursionlimit(10000000)

def main():
    A, B, C = [int(c) for c in input().split()]
    if (A - B) < C:
        C -= (A - B)
    else:
        C = 0
    print(C)


if __name__ == '__main__':
    main()

Solution (Python):
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline



def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [A, B, C] = [int(input_raw[0]), int(input_raw[1]), int(input_raw[2])]
    print max(0, C - (A - B))

if __name__ == '__main__':
    main()

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

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

print(c-d) if d < c else print(0)

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

temp = A - B
temp2 = C - temp

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

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

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

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

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):
import sys
def input():
    return sys.stdin.readline()[:-1]

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

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

Solution (Python):
from collections import Counter
from collections import deque
from functools import reduce
from operator import mul
from pprint import pprint
import bisect
import copy
import fractions
import itertools
import math
import queue
import random
import sys
import time
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) 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 MI(): return map(int, sys.stdin.readline().split())
def II(): return int(sys.stdin.readline())
def IS(): return input()
def C(x): return Counter(x)
def GCD_LIST(numbers): return reduce(fractions.gcd, numbers)
def LCM_LIST(numbers): return reduce(LCM, numbers)
def LCM(m, n): return (m * n // fractions.gcd(m, n))
def COMBINATION(n, r):
    if n < 0 or r < 0 or n < r:
        return 0
    r = min(n-r, r)
    if r == 0:
        return 1
    o = reduce(mul, range(n, n - r, -1))
    u = reduce(mul, range(1, r + 1))
    return o // u
class UnionFind():

    def __init__(self, n):
        self.n = n
        self.node = [i for i in range(n)]
        self.size = [1 for _ in range(n)]

    def same(self, x, y):
        return bool(self.root(x) == self.root(y))

    def root(self, x):
        if self.node[x] == x:
            return x
        else:
            self.node[x] = self.root(self.node[x])  
            return self.node[x]

    def unite(self, x, y):
        x, y = self.root(x), self.root(y)
        if x == y:
            return  
        if self.size[x] < self.size[y]:
            x, y = y, x
        self.node[y] = x
        self.size[x] += self.size[y]

    def return_size(self, x):
        return self.size[self.root(x)]


a, b, c = MI()
ans = c - (a - b)
print(max(ans, 0))

Solution (Python):
a, b, c = map(int, input().split())
print(0 if a - b >= c else 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(i) for i in input().split()]
if a-b > c:
    print(0)
else:
    print(c-(a-b))

Solution (Python):
def main():
     a,b,c=map(int,input().split())
     print(max(0,c-a+b))
     
if __name__ == '__main__':
     main()

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

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

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

Solution (Python):



def main():
    a, b, c = (int(z) for z in input().split())
    move = min(c, a - b)
    res = c - move
    print(res)


if __name__ == "__main__":
    main()

Solution (Python):

"""
AtCoder A
"""
 
import sys, math, random
import numpy as np
 







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 list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LLS(): return [list(sys.stdin.readline().rstrip()) for _ in sys.stdin.readlines()]
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 main():
    A, B, C = list(map(int,input().split()))
    sub=0
    if A>B:
        sub=A-B
    else:
        sub=0
    if sub>C:
        print("0")
    else:
        print(C-sub)
 
 
 
if __name__ == "__main__":
    main()

Solution (Python):
from sys import stdin

A, B, C = [int(x) for x in stdin.readline().rstrip().split()]

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

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

move = min(A-B, C)

print(C - move)

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
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 II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

debug = True


def dprint(*objects):
    if debug == True:
        print(*objects)

def solve():
    a, b, c = LI()
    rest = a - b
    if rest >= c:
        print(0)
    else:
        print(c-rest)

solve()

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

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

Solution (Python):

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


if __name__ == "__main__":
    main()

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

Solution (Python):
import sys

def input():
    return sys.stdin.readline().rstrip()

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

    ans = c - (a-b)
    if ans > 0:
        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):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

a, b , c = MAP()
d = (a-b)

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

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

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

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

Solution (Python):
import sys

input = sys.stdin.readline

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

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

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

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

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

Solution (Python):

a, b, c = [int(el) for el in input().split(' ')]
print(max(c-(a-b), 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 = [int(i) for i in input().split()]
if(B+C > A):
  print(C-(A-B))
else:
  print(0)

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

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

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

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

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

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

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

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

t = c - a + b

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

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

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

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

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

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

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

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

nokori = c - (a - b)

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

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

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

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

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

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

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

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

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

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

Solution (Python):


def read_int():
    return int(input())
 
 
def read_int_n():
    return list(map(int, input().split()))
 
 
def read_str():
    return input()
 
 
def read_str_n():
    return list(map(int, input().split()))

def main():
    a,b,c = read_int_n()
    if a-b > c:
        print(0)
    else:
        print(c - a + b)

main()

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

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

Solution (Python):
''' بِسْمِ اللَّهِ الرَّحْمَٰنِ الرَّحِيمِ '''

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

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline


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


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(A, B, C):
    return max(0, C - (A - B))


def main():
    A, B, C = read_int_n()
    print(slv(A, B, C))


if __name__ == '__main__':
    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(c-a+b, 0))

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

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