qyliang/CodeNanoFix huggingface dataset:
Buggy code:
a,b,k=map(int,input().split())
if a >= k:
  print(0,a+b-k)
else:
  print(a-k,b)

Fixed code:
a, b, k = map(int, input().split())
if a >= k:
    print(a - k, b)
elif a + b >= k:
    print(0, a+b-k)
else:
    print(0, 0)
Buggy code:
a, b, k = map(int, input().split())
if a-k >= 0:
    print(a-k, b)
elif b-(a-k) >= 0:
    print('0', b-(a-k))
else:
    print('0', '0')

Fixed code:
a, b, k = map(int, input().split())

if a >= k:
    a -= k

elif a < k:
    k -= a
    a = 0
    if b >= k:
        b -= k
    else:
        b = 0

print(a, b)
Buggy code:
A,B,K = map(int,input().split())

if A-K>=0:
    print(A-K,end=" ")
    print(B)
elif A-K<0 and K-A-B>=0:
    print("0",end=" ")
    print(B-(K-A))
else:
    print("0 0")

Fixed code:
A,B,K = map(int,input().split())

if A-K>=0:
    print(A-K,end=" ")
    print(B)
elif A-K<0 and A+B-K>=0:
    print("0",end=" ")
    print(B-(K-A))
else:
    print("0 0")
Buggy code:
A,B,K = map(int,input().split())

a = A-K
if a < 0:
  A = 0
  B = max(0, B+a)

print(a, B)


Fixed code:
A,B,K = map(int,input().split())

a = A-K
if a < 0:
  A = 0
  B = max(0, B+a)

print(max(0,a), B)
Buggy code:
A, B, K = [int(x) for x in input().split(" ")]

if A >= K:
  print("{} {}".format(A-K, B))
elif A < K and A+B => K:
  print("{} {}".format(0, A+B-K))
else:
  print(0)

Fixed code:
A, B, K = [int(x) for x in input().split(" ")]

if A >= K:
  print("{} {}".format(A-K, B))
elif A < K and A+B >= K:
  print("{} {}".format(0, int(A-K/2+B-K/2)))
else:
  print(0, 0)
Buggy code:
a,b,k = map(int,input().split())
beat = min(b,k)
b -= beat
k -= beat
aeat = min(a,k)
a -= aeat
print(a,b)

Fixed code:
a,b,k = map(int,input().split())
aeat = min(a,k)
a -= aeat
k -= aeat
beat = min(b,k)
b -= beat
print(a,b)
Buggy code:
A,B,K=map(int,input().split())

if A-K=>0:
  print(A-K,B)
elif (A+B)<=K:
  print(0,0)
else:
  print(0,A+B-K)

Fixed code:
A,B,K=map(int,input().split())
if K <= A:
  print(A-K , B)
elif A < K <= A+B:
  print(0, A+B-K)
else:
  print(0,0)
Buggy code:
taka, aoki, times= map(int,input().split())
if taka + aoki > times:
    if taka < times:
        print(0,aoki - (times - taka))
    elif taka > times:
        print(taka - times, aoki)
    else:
        print(0,0)
elif taka = times:
    print(0,aoki)
else:
    print(0,0)


Fixed code:
taka, aoki, times= map(int,input().split())
if taka + aoki > times:
    if taka < times:
        print(0,aoki - (times - taka))
    elif taka > times:
        print(taka - times, aoki)
    else:
        print(0,aoki)
else:
    print(0,0)
Buggy code:
a,b,k=map(int,input().split())
if k<=a:
    print(a-k, b)
elif a<k<b:
    print("0", b-(k-a))
else:
    print("0", "0")


Fixed code:
a,b,k=map(int,input().split())
if k<a:
    print(a-k, b)
elif a<=k<=a+b:
    print("0", b-(k-a))
elif a+b<k:
    print("0", "0")
Buggy code:
a, b, k = (int(i) for i in input().split())
x=a-k
if x < 0:
    y=b+x
    print("0 ", y)
    exit (0)
print (x, b)

Fixed code:
a, b, k = (int(i) for i in input().split())
x=a-k
if x < 0:
    y=b+x
    if y < 0:
        print ("0 0")
        exit (0)
    print("0", y)
    exit (0)
print (x, b)
Buggy code:
a,b,k = map(int,input().split())

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

Fixed code:
a,b,k = map(int,input().split())

if a>=k:
    print(int(a-k),b)
else:
    if a+b>=k:
        print(0,int(a+b-k))
    else:
        print(0,0)
Buggy code:
A,B,K=map(int,input().split())

if A-K<=0:
	B=B+A-K
	A=0
	if B<=0:
		B=0
if A-K>0:
	B=B-(A-K)
	A=A-K
    if B<=0:
		B=0
print(A,B)


Fixed code:
A,B,K=map(int,input().split())

if A-K<=0:
	B=B+A-K
	A=0
	if B<=0:
		B=0
if A-K>0:
	B=B
	A=A-K
print(A,B)
Buggy code:
a,b,k=map(int,input().split())
print(a-k,b) if k-a<=0 else print(0,b-k) if b-(k-a)>=0 else print(0,0)

Fixed code:
a,b,k=map(int,input().split())
print(a-k,b) if k-a<=0 else print(0,b-(k-a)) if b-(k-a)>=0 else print(0,0)
Buggy code:
A, B, K = map(int, input().split())

# for i in range(K):
#     if A > 0:
#         A -= 1
#     elif B > 0:
#         B -= 1

if A >= K:
    A -= K
elif A+B >= K:
    A = 0
    B -= K-A

if B < 0:
    B = 0

print(A, B)

Fixed code:
A, B, K = map(int, input().split())

# for i in range(K):
#     if A > 0:
#         A -= 1
#     elif B > 0:
#         B -= 1

if A >= K:
    A -= K
elif A+B >= K:
    B -= K-A
    A = 0
    if B < 0:
        B = 0
elif A+B < K:
    A = 0
    B = 0

print(A, B)
Buggy code:
takahashi,aoki,count = map(int,input().split())
if count >= takahashi:
	aoki = aoki - count + takahashi
	takahashi = 0
else:
	takahashi = takahashi - count
aoki = (aoki < 0) and 0
print(takahashi,aoki)


Fixed code:
takahashi,aoki,count = map(int,input().split())
if count >= takahashi:
	aoki = aoki - count + takahashi
	takahashi = 0
else:
	takahashi = takahashi - count
if aoki < 0:
	aoki = 0
print(takahashi,aoki)
Buggy code:
a, b, k = [int(i) for i in input().split()]

if k > a+b:
  a = 0
  b = 0
elif k > a:
  a = 0
  b = a+b-k
else:
  a = k-a
  
print(a, b)

Fixed code:
a, b, k = [int(i) for i in input().split()]

if k > a+b:
  a = 0
  b = 0
elif k > a:
  b = a+b-k
  a = 0
else:
  a = a-k
  
print(a, b)
Buggy code:
a, b, k = list(map(int,input().split()))
if a >= k:
  a = a - k
elif a+b > k:
  a = 0
  b = b - (k - a)
else:
  a = 0
  b = 0
print(a,b)

Fixed code:
a,b,k=map(int,input().split())
if(a>=k):
    print(a-k,b)
elif(a+b>=k):
    print(0,a+b-k)
else:
    print(0,0)
Buggy code:
import sys
def input():
    return sys.stdin.readline()[:-1]

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

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

print(A,B)

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

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

if K>=A:
    K -= A
    A = 0
    if K>=B:
        B = 0
    else:
        B -= K
else:
    A -= K

print(A,B)
Buggy code:
a, b, k = map(int, input().split())

if k >= a + b:
    print(0, 0)
    
if a <= k < a + b:
    print(0, a + b - k)
    
else:
    print(a - k, b)

Fixed code:
a,b,k=map(int,input().split())

if k>=a:
    print(0,max(0,b+a-k))
else:
    print(max(0,a-k),b)
Buggy code:
A,B,K=map(int,input(),split())
if A>=K:
  print(A-K,B)
elif K>A and A+B>=K:
  print(0,B-K+A)
else:
  print(0,0)

Fixed code:
A,B,K=map(int,input().split())
if A>=K:
  print(A-K,B)
elif K>A and A+B>=K:
  print(0,B-K+A)
else:
  print(0,0)
Buggy code:
A,B,K=map(int,input().split())
print(A-K,B if A>=K else 0,B+A-K if A+B>=K else 0,0)

Fixed code:
A,B,K=map(int,input().split())
if A>=K :
    print(A-K,B)
elif A+B>=K :
    print(0,A+B-K)
else :
    print(0,0)
Buggy code:
i = list(map(int, input().split()))
lst=[]
if i[0]<i[2]:
  i[0]=0
  i[1]=i[1]-(i[2]-i[0])
  if i[1]<0:
    i[1]=0
else:
  i[0]-=i[2]
lst.append(i[0])
lst.append(i[1])
print(lst)

Fixed code:
i = list(map(int, input().split()))

if i[0]<i[2]:
  
  i[1]=i[1]-(i[2]-i[0])
  i[0]=0
  if i[1]<0:
    i[1]=0
else:
  i[0]-=i[2]

print(i[0],i[1])
Buggy code:
A,B,K=map(int,input().split())
if A-K>=0:
  print(A-K,B)
else:
  B=B-(K-A)
  if B<=0:
    print(0,0)
    break
  print(0,B)
  
  


Fixed code:
A,B,K=map(int,input().split())
A,K=A-K,K-A
if A<0:
  A=0
if K<0:
  K=0
print(A,B-K if B>K else 0)
Buggy code:
A, B, K = map(int, input().split())
quant = A + B

if quant - K <= 0:
    print('0 0')
else:
    RNT = A - K  # RemainNumTime
    a = max(RNT, 0)
    b = min(B + RNT, B)
    print(a + ' ' + b)

Fixed code:
A, B, K = map(int, input().split())
quant = A + B

if quant - K <= 0:
    print('0 0')
else:
    rnt = A - K  # RemainNumTime
    a = max(rnt, 0)
    b = min(B + rnt, B)
    print(str(a) + ' ' + str(b))
Buggy code:
a,b,k=map(int,input().split())
if a==k:
  print(0,b)

elif a+b<=k:
  print(0,0)

  elif a>k:
  print(a-k,b)
  
else:
  print(0,b+a-k)
  
  
  


Fixed code:
a,b,k = map(int,input().split())

if a - k < 0 :
  if a + b - k < 0 :
    a = 0
    b = 0
  else :
    b = a + b - k
    a = 0
else :
  a -= k 

print(a,b)
Buggy code:
a,b,k=map(int,input().split())
if a==k:
  print('0',b)

elif a+b<=k:
  print('0','0')

  elif a>k:
  print(a-k,b)
  
else:
  print('0',b+a-k)
  
  
  


Fixed code:
a, b, k =map(int, input().split())

if k <= a:
   print(a - k, b)
elif a < k <= a+b:
   print(0, a+b-k)
else:
   print(0, 0)
Buggy code:
a,b,k=map(int,input().split())
if a=k:
  print('0',b)
  
elif a>k:
  print(a-k,b)
  
else:
  print('0',b+a-k)
  
  

Fixed code:
a, b, k = map(int, input().split())

if k >= a + b:
    a, b = 0, 0
elif k >= a:
    a, b = 0, b - (k - a)
else:
    a -= k
print(a, b)
Buggy code:
a,b,n=map(int(input()split()))
print(max(a-n,0),max(b-max(a-n,0),0))

Fixed code:
a,b,n=map(int,input().split())  
print(max(a-n,0),max(b-max(n-a,0),0))
Buggy code:
a,b,k=map(int,input().split())
m=max(a,k)
a-=m
k-=m
b-=k
print(a,max(b,0))

Fixed code:
a,b,k=map(int,input().split())
m=min(a,k)
a-=m
k-=m
b-=k
print(a,max(b,0))
Buggy code:
A, B, K = map(int, input().split())
if A >= K:
    A -= K
else:
    A = 0
    K -= A
    if B >= K:
        B -= K
    else:
        B = 0

print('{} {}'.format(A, B))

Fixed code:
A, B, K = map(int, input().split())
if A >= K:
    A -= K
else:
    K -= A
    A = 0
    if B >= K:
        B -= K
    else:
        B = 0

print('{} {}'.format(A, B))
Buggy code:
a,b,k = map(int, input().split())


if a > k:
    print('{} {}'.format(a-k,b))

elif (a + b) > k:
    print('0 {}'.format(a+b-k))

elif (a + b) < k:
    print('0 0')

Fixed code:
a,b,k = map(int, input().split())


if a >= k:
    print('{} {}'.format(a-k,b))

elif (a + b) > k:
    print('0 {}'.format(a+b-k))

elif (a + b) <= k:
    print('0 0')
Buggy code:
A, B, K = map(int, input().split())

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

Fixed code:
A, B, K = map(int, input().split())
if A >= K: 
    A -= K
else:
    B = max((A + B) - K, 0)
    A = 0
print(A,  B)
Buggy code:
A,B,K = map(int,input().split())
K=K-A
if K >=0:
    B=B-K
if A > 0:
    if A-K<0:
        A = 0
    else:
        A = A - K
print(A,B)

Fixed code:
A,B,K = map(int,input().split())
A1=A
if A-K<0:
    A = 0
else:
    A = A - K
K=K-A1
if K >=0:
    B=B-K
if B <0:
    B=0
print(A,B)
Buggy code:
input_list = list(map(int, input().split()))
takahashi = input_list[0]
aoki = input_list[1]
turn = input_list[2]
if takahashi >= turn:
    takahashi -= turn
else:
    takahashi = 0
    turn = turn - takahashi
    if turn > aoki:
        aoki = 0
    else:
        aoki -= turn
print(takahashi, aoki)

Fixed code:
input_list = list(map(int, input().split()))
takahashi = input_list[0]
aoki = input_list[1]
turn = input_list[2]
if takahashi >= turn:
    takahashi -= turn
else:
    turn -= takahashi
    takahashi = 0
    if turn > aoki:
        aoki = 0
    else:
        aoki -= turn
print(takahashi, aoki)
Buggy code:
a, b, k = map(int,input().split())
if (k >= a + b):
  print(0, 0)
elif (k >= a):
  print(0, k - a)
else:
  print(a - k, b)

Fixed code:
a, b, k = map(int, input().split())

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

    a = a - k
    if a < 0:
        k = a * -1
        a = 0
    else:
        k = k - a
    
    b = b - k if b > 0 else 0

    print(a, b - k)

if __name__ == '__main__':
    main()


Fixed code:
def main():
    a, b, k = list(map(int, input().split()))

    ans_a = a - k
    if ans_a < 0:
        k = ans_a * -1
        ans_a = 0
    else:
        k = k - a

    k = 0 if k < 0 else k

    b = b - k if b - k > 0 else 0

    print(ans_a, b)

if __name__ == '__main__':
    main()
Buggy code:
A,B,K = map(int, input().split())
if A >= K:
  print(A-K,B)
  else:
  print(0,B-(K-A))
  

Fixed code:
A, B, K = map(int, input().split())

if A > K:
    print(A - K, B)
else:
    print(0, max(0, B - K + A))
Buggy code:
A,B,K = map(int,input().split())

if K >= A:
    A = 0
else:
    A = A - K

K = K - A
if K > 0:
    if B >= K:
        B = B - K
    else:
        B = 0
        

print("{} {}".format(A, B))

Fixed code:
A,B,K = map(int,input().split())

K1 = K - A

if K >= A:
    A = 0
else:
    A = A - K

if K1 > 0:
    if B >= K1:
        B = B - K1
    else:
        B = 0
        

print("{} {}".format(A, B))
Buggy code:
a,b,k=map(int,input().split())
b=max(0,b-min(a-k,0))
a=max(0,a-k)
print(a,b)

Fixed code:
a,b,k=map(int,input().split())
b=max(min(b+a-k,b),0)
a=max(a-k,0)
print(a,b)
Buggy code:
A, B, K = map(int(), input().split())

if A >= K:
  a = A - K
  b = B
elif A+B >= K:
  a = 0
  b = A + B - K
else:
  a = 0
  b = 0

print(str(a) + " " + str(b))

Fixed code:
A, B, K = map(int, input().split())
     
if A >= K:
  a = A - K
  b = B
elif A+B >= K:
  a = 0
  b = A + B - K
else:
  a = 0
  b = 0
     
print(str(a) + " " + str(b))
Buggy code:
def resolve():
    A, B, K = map(int,input().split())

    for i in range(K):
        if 1 <= A:
            A-=1
        elif 1 <= B:
            B-=1

    print("{} {}".format(A,B))

if __name__ == "__main__":
    resolve()

Fixed code:
def resolve():
    A, B, K = map(int,input().split())

    '''
    for i in range(K):
        if 1 <= A:
            A-=1
        elif 1 <= B:
            B-=1
    '''

    if A < K:
        K -= A
        A = 0
        if B <= K:
            B = 0
        else:
            B -= K
    elif K <= A:
        A -= K

    print("{} {}".format(A,B))

if __name__ == "__main__":
    resolve()
Buggy code:
a,b,k=map(int,input().split())
if a>=k:a-=k
else:
  b=max(b-k-a,0)
  a=0
print(a,b)

Fixed code:
a,b,k=map(int,input().split())

if a>k:
    print(a-k,b)
else:
    print(0,max(b-(k-a),0))
Buggy code:

A, B, K = map(int, input().strip().split(" "))
print(A, B, K)

if A > K:
    A -= K
    K = 0

else:
    K -= A
    A = 0

if B > K:
    B -= K
    K = 0

else:
    B = 0
    
print("{} {}".format(A, B))

Fixed code:

A, B, K = map(int, input().strip().split(" "))
# print(A, B, K)

if A > K:
    A -= K
    K = 0

else:
    K -= A
    A = 0

if B > K:
    B -= K
    K = 0

else:
    B = 0
    
print("{} {}".format(A, B))
Buggy code:
A, B, K = map(int, input().split())

if A + B <= K:
    A = 0
    B = 0
else:   
    if A <= K:
        A = 0
        B = K - A
    else:
        A = A - K

print(A,B)


Fixed code:
A, B, K = map(int, input().split())

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

print(A,B)
Buggy code:
a,b,c = map(int, input().split())
 
print(max(0,a-c),max(0,max(0,c-a)))

Fixed code:
a,b,c = map(int, input().split())
 
print(max(0,a-c),max(0, b - max(0,c-a)))
Buggy code:
a, b, k = map(int, input().split())

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

Fixed code:
a, b, k = map(int, input().split())
if k >= (a+b):
    print(0, 0)
elif k >= a:
    print(0, b-(k-a))
else:
    print(a-k, b)
Buggy code:
A, B, K = map(int, input().split())
if A >= K:
  A = A - K
elif A < K:
  A = 0
  B = B - (K - A)

print('{} {}'.format(A, max(0, B)))

Fixed code:
A, B, K = map(int, input().split())
if A >= K:
  A = A - K
elif A < K:
  B = B - (K - A)
  A = 0
 
print('{} {}'.format(A, max(0, B)))
Buggy code:
A,B,K = map(int, input().split())

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

Fixed code:
A,B,K = map(int, input().split())

if K<=A:
  print(A-K,B)
else:
  if A+B >= K:
    print(0,B-(K-A))
  else:
    print(0,0)
Buggy code:
a, b, k = map(int, input().split())
if a <= k:
    print(0, (a+k)-b)
elif a > k:
    print((a-k), b)


Fixed code:
a,b,k = map(int, input().split())
if k >= a+b:
  print(0,0)
elif k >= a:
  print(0,b-k+a)
else:
  print(a-k,b)
Buggy code:
a,b,c= map(int, input().split())
if  a+b<=c:
    print("0 0")
if a-c<0 and a+b>=c:
    print(0,b-(c-a))
else:
    print(a-c,b)

Fixed code:
a,b,c= map(int, input().split())
if  a+b<=c:
    print("0 0")
elif a-c<0 and a+b>=c:
    print(0,b-(c-a))
else:
    print(a-c,b)
Buggy code:
import sys
sys.setrecursionlimit(10000000)
# input = sys.stdin.readline
# from bisect import *
# from collections import *
# from heapq import *
# import functools
# import itertools
# import math
INF = 500000
MOD = 10**9+7

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


Fixed code:
import sys
sys.setrecursionlimit(10000000)
# input = sys.stdin.readline
# from bisect import *
# from collections import *
# from heapq import *
# import functools
# import itertools
# import math
INF = 500000
MOD = 10**9+7

a, b, k = map(int, input().split())
print(max(0, a-k), max(0, b-max(0, k-a)))
Buggy code:
a,b,k=map(int,input())
if a+b<=k:print(0,0)
elif a<=k:print(0,a+b-k)
else:print(a-k,b)

Fixed code:
a,b,k=map(int,input().split())
if a+b<=k:print(0,0)
elif a<=k:print(0,a+b-k)
else:print(a-k,b)
Buggy code:
a, b, c = input().split()
x = int(a)
y = int(b)
z = int(c)
if z >= x:
    z -= x
    x = 0

else:
    x -= z
    z = 0

if z >= y:
    z -= y
    y = 0

else:
    y -= z
    z = 0


Fixed code:
a, b, c = input().split()
x = int(a)
y = int(b)
z = int(c)
if z >= x:
    z -= x
    x = 0

else:
    x -= z
    z = 0

if z >= y:
    z -= y
    y = 0

else:
    y -= z
    z = 0

print(str(x),str(y))
Buggy code:
x = input().split()
A, B, K = [int(i) for i in x]
if A - K > 0:
  print(str(A-K) + " " + str(B-K))
elif B - K > 0:
  print("0" + " " + str(A+B-K))
else:
  print("0 0")

Fixed code:
x = input().split()
A, B, K = [int(i) for i in x]
if A - K > 0:
  print(str(A-K) + " " + str(B))
elif A+B-K > 0:
  print("0" + " " + str(A+B-K))
else:
  print("0 0")
Buggy code:
A,B,K = map(int,input().split())
if (A - K) <= 0 and 0 < B - K + A :
    B = B - K + A
    print(0,B)
elif (A - K) <= 0 and B - K + A < 0:
    print(0,0)
else:
    print(A-K,B)

Fixed code:
A,B,K = map(int,input().split())
if (A - K) <= 0 and 0 < B - K + A :
    B = B - K + A
    print(0,B)
elif (A - K) <= 0 and B - K + A <= 0:
    print(0,0)
elif 0 < (A - K):
    print(A-K,B)
Buggy code:
a,b,k = list(map(int, input().split()))

if a >= k:
    print(a-k,b)

if b >= k-a:
    print(0,b + (a - k))

print(0, 0)


Fixed code:
a,b,k = list(map(int, input().split()))

if a >= k:
    print(a-k,b)
elif b >= k-a:
    print(0,b + (a - k))
else:
    print(0,0)
Buggy code:
a, b, k = map(int, input().split())
if k <= a:
    print(a-k, b)
else:
    if a+b > k:
        print(0, 0)
    else:
        print(0, a+b-k)


Fixed code:
a, b, k = map(int, input().split())
if k <= a:
    print(a - k, b)
elif k <= a + b:
    print(0, b - (k - a))
else:
    print(0, 0)
Buggy code:
a, b, k = [int(v) for v in input().split()]

if k >= a:
  a = 0
  k -= a
else:
  a -= k
  k = 0

if k >= b:
  b = 0
else:
  b -= k

print(a, b)

Fixed code:
a, b, k = [int(v) for v in input().split()]

if k >= a:
    k -= a
    a = 0
else:
    a -= k
    k = 0

if k >= b:
    b = 0
else:
    b -= k

print(a, b)
Buggy code:
A, B, K = map(int, input().split())

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

Fixed code:
A, B, K = map(int, input().split())

print(max(0, A-K), max(0, B-max(0, K-A)))
Buggy code:
A,B,K=map(int,input().split())

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

Fixed code:
A,B,K=map(int,input().split())

if A>=K:
    print(A-K,B)
else:
    print(0,max(0,B-(K-A)))
Buggy code:
inputted = list(map(int, input().split()))
A = 2
B = 3
K = 3

A2 = max([0, A - K])
B2 = B - max([0, K - A])

answer = '{} {}'.format(A2, B2)

print(answer)


Fixed code:
inputted = list(map(int, input().split()))
A = inputted[0]
B = inputted[1]
K = inputted[2]

A2 = max([0, A - K])
B2 = max([0, B - max([0, K - A])])

answer = '{} {}'.format(A2, B2)

print(answer)
Buggy code:
t,a,k = [x for x in list(map(int,input().split()))]
if k>=t:
  if abs(t-k) > a:
    t = 0
    a = 0
  else:
    t = 0
    a = a-abs(t-k)
   print(t,a)
else:
  t = t-k
  print(t,a)
  

Fixed code:
t,a,k = [x for x in list(map(int,input().split()))]
if k>=t:
    if k-t > a:
        t = 0
        a = 0
    else:
        a = a - (k-t)
        t = 0
    print(t,a)
else:
    t = t-k
    print(t,a)
Buggy code:
a, b, c = [int(x) for x input().split()]

ma = min(a, c)
a = a-ma
c = c-ma
ma = min(c, b)
b = b - ma
print(str(a)+" "+str(b))

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

ma = min(a, c)
a = a-ma
c = c-ma
ma = min(c, b)
b = b - ma
print(str(a)+" "+str(b))
Buggy code:
def main():
  [a, t, k] = [int(i) for i in input().split()]
  if a + t >= k:
    a = 0
    t = 0
  elif a >= k:
    a = 0
    t = t - (k -a)
  else:
    a = a - k:

if __name__ == "__main__":
  main()
  

Fixed code:
def main():
  [a, t, k] = [int(i) for i in input().split()]
  if a + t <= k:
    a = 0
    t = 0
  elif a <= k:
    t = t - (k - a)
    a = 0
  else:
    a = a - k
  print(a, t)

if __name__ == "__main__":
  main()
Buggy code:
import sys

sys.setrecursionlimit(1000000000000000)


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

if a >= k:
    a = a - k
    print("{} {}".format(a, b))
elif k > a and a + b >= k:
    b = a + b - k
    print("{} {}".format(0, b))
else:
    print("{} {}".format(0, 0))



Fixed code:
import sys

sys.setrecursionlimit(1000000000)


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

if a >= k:
    a = a - k
    print("{} {}".format(a, b))
elif k > a and a + b >= k:
    b = a + b - k
    print("{} {}".format(0, b))
else:
    print("{} {}".format(0, 0))
Buggy code:

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

print(a,b,k)

if a>=k:
    print(a-k,b)
elif k>=a+b:
    print(0,0)
else:
    print(0,b-(k-a))


Fixed code:
a,b,k = map(int, input().split())
if a>=k:
    print(a-k, b)
elif (a<k) and (a+b>k):
    print(0,a+b-k)
else:
    print(0,0)
Buggy code:
# -*- coding: utf-8 -*-
stra, strb, strk = input().split()
a = int(stra)
b = int(strb)
k = int(strk)
if a >= k :
  a = a - k
else:
  a = 0
  b = b - (a - k)
  if b < 0:
    b = 0
print("{} {}".format(a, b))


Fixed code:
# -*- coding: utf-8 -*-
stra, strb, strk = input().split()
a = int(stra)
b = int(strb)
k = int(strk)
if a >= k :
  a = a - k
  k = 0
else:
  k = k - a
  a = 0
#  print("{} {} {}\n".format(a,b,k))

  if b >= k:
    b = b - k
  else:
    b = 0

print("{} {}".format(a, b))
Buggy code:
A,B,K = map(int,input().split())

if A>=K:
	A = A-K
elif A+B <= K:
	A,B =0,0
else:
	A = 0
	B = A+B-K
print(A,B)


Fixed code:
A,B,K=map(int,input().split())
if (A-K)>=0:
  print(A-K,B)
elif (B-(K-A))>=0:
  print(0,B-(K-A))
else:
  print(0,0)
Buggy code:
A,B,K = map(int,input().split())

if K < A:
    A = A - K
    print(A,B)
else:
    K = K - A
    A = 0
    print(K)
    if K < B:
        B -= K
        print(A,B)
    else:
        B = 0
        print(A,B)


Fixed code:
A,B,K = map(int,input().split())

if K < A:
    A = A - K
    print(A,B)
else:
    K = K - A
    A = 0
#     print(K)
    if K < B:
        B -= K
        print(A,B)
    else:
        B = 0
        print(A,B)
Buggy code:
A, B, K= map(int, input().split())

if A >= K:
  ans_t = A - K
  ans_a = B
elif B >= ( K - A):
  ans_t = 0
  ans_a = B - ( K - A)
else:
  ans_t = 0
  ans_a = 0

print( ’{} {}’.format( ans_t, ans_a))


Fixed code:
A, B, K= map(int, input().split())
 
if A >= K:
  ans_t = A - K
  ans_a = B
elif B >= ( K - A):
  ans_t = 0
  ans_a = B - ( K - A)
else:
  ans_t = 0
  ans_a = 0
 
print( '{} {}'.format( ans_t, ans_a))
Buggy code:
a,b,k = map(int, input().split( ))

a1 = max(a-k,0)
a2 = b-(k-a1)
print(a1,a2)

Fixed code:
a,b,k = map(int, input().split( ))

a1 = max(a-k,0)
a2 = max(b-(k-(a-a1)),0)
print(a1,a2)
Buggy code:
a, b, k = map(int, input().split())
if a + b <= k:
    print("0 0")
elif a >= k:
    print("{} {}".format(a-k, b))
elif k > a:
    print("{} {}".format(0, b-a+k))

Fixed code:
a, b, k = map(int, input().split())
if a + b <= k:
    print("0 0")
elif a >= k:
    print("{} {}".format(a-k, b))
elif k > a:
    print("{} {}".format(0, b+a-k))
Buggy code:
a, b, k = map( int, input().split())

a_aft = max( 0, a - k)
b_aft = max( 0, b - ( a - k ))
print( a_aft, b_aft )

Fixed code:
a, b, k = map( int, input().split())
 
a_aft = max( 0, a - k )
b_aft = max( 0, b - max( 0, k - a ))
print( a_aft, b_aft )
Buggy code:
base = input().split()
a = int(base[0])
b = int(base[1])
k = int(base[2])
if a>=k:
    print(a-k,b)
elif a+b<k:
    print(0,0)
else:
    print(0,k-a-b)

Fixed code:
base = input().split()
a = int(base[0])
b = int(base[1])
k = int(base[2])
if a>=k:
    print(a-k,b)
elif a+b<k:
    print("0 0")
else:
    print(0,a+b-k)