qyliang/CodeNanoFix huggingface dataset:
Buggy code:
A,B,K = map(int,input().split())
if A >= K:
    A -= K
    K = 0
else:
    A = 0
    K -= A
if B >= K:
    B -= K
    K = 0
else:
    B = 0
    K -= B
print(A,B)


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

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

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

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

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

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

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

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

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

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

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

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

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

if A <= K:
  K -= A
  A = 0

else:
  A -= K
  K = 0

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

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

if k>a+b:
    print("0 0")    
elif k>a:
    print("0 "+str(a+b-k))
else:
    print(str(a-k)+" "+str(b))



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

if a > k:
    print(a-k, b)
else:
    print(0, min(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())
print(A,B,K)
if A+B<=K:
    print(0,0)
elif K>=A:
    print(0,B-K+A)
else:
    print(A-K,B)

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

if A>K:
    print(A-K,B)
elif A<=K and B+A-K>=0:
    print(0,B+A-K)
else:
    print(0,0)
Buggy code:
i = input().split()
a = int(i[0])
b = int(i[1])
k = int(i[2])

if k >= a+b:
  a = b = 0

elif k >= a:
  a = 0
  b = b - (k + a)

else:
  a = a - k

print(a,b)

Fixed code:
i = input().split()
a = int(i[0])
b = int(i[1])
k = int(i[2])
c = a 
d = b

if k >= a+b:
  c = d = 0

elif k == a:
  c = 0

elif k > a:
  c = 0
  d = b - (k - a)

else:
  c = a - k
  
print(c,d)
Buggy code:
a,b,k = map(int,input().split())

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

print(a,b)

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

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



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

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

print(a,b)

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

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

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

if A >= K:
    print(A-K, B)
elif A < K <= A+B:
    print(0, B-(K-A))
else:
    print(0, 0)
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:
a,b,k=map(int,input().split())
if k>=a:
  A=0
  if k-a>=b:
    B=0
  else:
    B=b
else:
  A=a-k
  B=b
print('{}{}'.format(A,B))

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

elif A > K:
    print(A-K, B)
else:
    print(0, max(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:
  print(A-K,B)
elif K > B:
  print(0,A+B-K) 
else:
  print(0,0)

Fixed code:
A,B,K=map(int,input().split())
C=A+B-K
if C<=0:
  A=0
  B=0
else:
  if A>=K:
    A=A-K
  else:
    B=B-(K-A)
    A=0
print(A,B)
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)
else:
    k -= a
    print(0,max(0,b-k))
Buggy code:
a,b,k = [int(i) for i in input().split()]
 
if a-k>0:
    print(a-k,b)
else:
    print(0,min(0,b-(k-a)))

Fixed code:
a,b,k = [int(i) for i in input().split()]
 
if a-k>0:
    print(a-k,b)
else:
    print(0,max(0,b-(k-a)))
Buggy code:
A, B, K = map(int, input().split())


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


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

Fixed code:
a,b,k=map(int,input().split())
if a>=k:
  a1=a-k
  print(a1,b)
else:
  a1=0
  if b>=k-a:
    b1=b-(k-a)
  else:
    b1=0
  print(a1,b1)
Buggy code:
a,b,k=map(int,input().split())
if a>=k:
    print(a-k,b)
elif 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 a+b>k:
    print(0, a+b-k)
else:
    print(0, 0)
Buggy code:
a,b,k = map(int, input().split())

if k > a+b:
  if k > a:
    print('0 ' + str(b-(k-a)))
  else:
    print(str(k-a)+' '+str(b))
else:
  print('0 0')

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

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

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

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

if a>=k:
	print(a-k, b)
else:
	k-=a
	b-=k
	print(0, max(0, b))
Buggy code:
Takahashi, Aoki, count = input().split()

tk = int(Takahashi)
ak = int(Aoki)
c = int(count)

t = 0

if tk >= c:
    tk = tk - c

else:
    tk = 0
    c = c - tk
    if ak >= c:
        ak = ak - c
    else:
        ak = 0

print(tk, ak)

Fixed code:
Takahashi, Aoki, count = input().split()

tk = int(Takahashi)
ak = int(Aoki)
c = int(count)

t = 0


if tk >= c:
    tk = tk - c

else:
    c = c - tk
    tk = 0
    if ak >= c:
        ak = ak - c
    else:
        ak = 0

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

Fixed 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,b-(k-a))
Buggy code:
ABK=list(map(int,input().strip().split()))

A=ABK[0]
B=ABK[1]
K=ABK[2]

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

print(A,B)

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

A=ABK[0]
B=ABK[1]
K=ABK[2]

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

print(A,B)
Buggy code:
A, B, K = [int(_) for _ in input().split()]
if K >= A:
    A = 0
    B -= (K - A)
    if B < 0:
        B = 0
else:
    A -= K
print(A, B)


Fixed code:
A, B, K = [int(_) for _ in input().split()]
if K >= A:
    K -= A
    A = 0
    B -= K
    if B < 0:
        B = 0
else:
    A -= K
print(A, B)
Buggy code:
A, B, K = map(int, input().split())

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

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

if a <= k:
  if b -(k - a) <=0:
    print('0 0')
  else:
    s = 0
    t = b - (k - a)
    print('{} {}'.format(s, t))
else:
  s = a - k
  t = b
  print('{} {}'.format(s, t))


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

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

print("{} {}".format(a,b))
  

Fixed code:
a, b, k = map(int, input("").split(" "))
if k >= a:
    print("0 {}".format(b-(k-a) if k-a < b else 0))
else:
    print("{} {}".format(a-k, b))
Buggy code:
a,b,k = map(int,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 = map(int, input().split())

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

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

  
  
    

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


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

elif A <= K:
    C = K - A
    print(0, B-C)

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

Fixed code:
a,b,k=map(int,input().split())
c=max(a-k,0)
k-=a-c
d=max(b-k,0)
print(c,d)
Buggy code:
a, b, k =map(int,input().split())
if a>k:
    print(a-k,b)
elif 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 a+b>=k:
    print(0,b-(k-a))
else:
    print(0,0)
Buggy code:
A, B, K = map(int, input().split())
if(K-A >= 0):
  print(K-A, B)
elif(K-A<0 and (K-A)-B>=0):
  print(0, (K-A)-B)
else:
  print(0, 0)

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

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

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

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

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


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


Fixed code:
a,b,k = map(int,input().split())
print(" ".join(map(str,[max(0,a-k),max(0,b-max(0,k-a))])))
Buggy code:
A,B,K = map(int, input().split())

takahashi_cookie = A
aoki_cookie = B
iteration = K

if 0 <= takahashi_cookie - iteration:
  takahashi_cookie -= iteration
 
elif 2 <= aoki_cookie + takahashi_cookie - iteration:
  aoki_cookie = aoki_cookie + takahashi_cookie - iteration
  takahashi_cookie = 0

else:
  takahashi_cookie = 1
  aoki_cookie = 1

print(str(takahashi_cookie) + ' ' + str(aoki_cookie))


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

takahashi_cookie = A
aoki_cookie = B
iteration = K

if 0 <= takahashi_cookie - iteration:
  takahashi_cookie -= iteration
 
elif 0 <= aoki_cookie + takahashi_cookie - iteration:
  aoki_cookie = aoki_cookie + takahashi_cookie - iteration
  takahashi_cookie = 0

else:
  takahashi_cookie = 0
  aoki_cookie = 0

print(str(takahashi_cookie) + ' ' + str(aoki_cookie))
Buggy code:
a, b, c = map(int, input().split())
if c <= a:
  print(a-c, b)
else:
  print(a-c, max(b-c, 0))

Fixed code:
a, b, c = map(int, input().split())
if c <= a:
    print(a-c, b)
else:
    print(0, max(b-(c-a), 0))
Buggy code:
n_list = n.split(" ")
a = int(n_list[0])
b = int(n_list[1])
k = int(n_list[2])

if k < a:
    a = a-k
elif k >= a and k-a < b:
    a = 0
    b = b - (k-a)
elif k-a >= b:
    a = 0
    b = 0

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

Fixed code:
n = input()
n_list = n.split(" ")
a = int(n_list[0])
b = int(n_list[1])
k = int(n_list[2])

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

print(A,B)

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

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

if k <= a:
    a -= k
elif a < k <= a + b:
    a = 0
    b -= k - a
else:
    a = 0
    b = 0
print('{} {}'.format(a, b))

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

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

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

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

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

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

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

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

Fixed code:
a,b,k = map(int,input().split())
if a < k:
  k -= a
  a = 0
else :
  a -= k
  k = 0

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

print(str(a)+ " " + str(b))
Buggy code:
a,b,k=map(int,input().split())
if k<=a:
    print(a-k,b)
elif a<k<=a+b:
    print(0,k-a)
elif a+b<k:
    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 = map(int,input().split())

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

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

ans1=0
ans2=0
if k>=a:
    ans1=0
    if a+b<=k:
        ans2=0
    else:
        ans2=b-(k-a)
else:
    ans1=a-k
    ans2=b
print(ans1,ans2)
Buggy code:
#coding:utf-8

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

if k <= a:
    a = a - k
elif a < k and k <= (a + b):
    b = k - a
    a = 0
elif (a + b) < k:
    a = 0
    b = 0

print(a, b)

Fixed code:
#coding:utf-8

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

if k <= a:
    a = a - k
elif a < k and k <= (a + b):
    b = b - (k - a)
    a = 0
elif (a + b) < k:
    a = 0
    b = 0

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



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, X = list(map(int,input().split()))
if A > X:
  print(A-X, B)
elif A <= x and B > X - A:
  print(0, B-(X-A))
elif A == 0 and B == 0:
  print(0,0)
else:
  print(0,0)

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

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

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



Fixed code:
a, b, k = map(int, input().split())
if a >= k:
	a = a - k
elif a + b >= k:
	b = b - k + a
	a = 0
else:
	a = b = 0
print(a, b)
Buggy code:
def actual(a, b, k):
    if a >= k:
        # return f'{a - k} {b}'
        return '{} {}'.format((a - k), b)

    if b > (k - a):
        # return f'0 {b - (k - a)}'
        return f'0 {}'.format(b - (k - a))

    return '0 0'

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

Fixed code:
def actual(a, b, k):
    if a >= k:
        # return f'{a - k} {b}'
        return '{} {}'.format((a - k), b)

    if b > (k - a):
        # return f'0 {b - (k - a)}'
        return '0 {}'.format(b - (k - a))

    return '0 0'

a, b, k = map(int, input().split())
print(actual(a, b, k))
Buggy code:
a,b,k = list(map(int,input().split(" ")))

if a > k:
    a -= k
    print(str(a) + " " + b)
else:
    left = k - a
    b -= left
    print(str(0) + " " + b)

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

if a > k:
    a -= k
    print(str(a) + " " + str(b))
else:
    left = k - a
    b -= left
    if b < 0:
        b = 0
    print(str(0) + " " + str(b))
Buggy code:
a,b,n = list(map(int, input().split()))

if n>a:
  a=0
  b-=(n-a)
  if b<0:
    b=0
else:
  a=n-a

print("%d %d" %(a,b))

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

if a == n:
  a = 0
elif a < n:
  b -= n-a
  a = 0
  if b < 0:
    b = 0
elif a > n:
  a -= n

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

Fixed code:
a, b, k = map(int, input().split())
a = a-k
if a < 0:
    b += a
print(max(a, 0), max(b, 0))
Buggy code:
def solve():
    A, B, K = map(int, input().split())
    ans = []
    if A+B <= K:
        ans = [0, 0]
    if A >= K:
        ans =[A-K, B]
    if A<K<=B:
        ans = [0, B+A-K]
    if K == 0:
        ans = [A, B]
    if A-K < 0:
        ans = [0, B+A-K]
    if A-K == 0:
        ans = [0, B]
    print(*ans)

Fixed code:
def solve():
    A, B, K = map(int, input().split())
    ans = []
    if A + B <= K:
        ans = [0, 0]
    elif K <= A:
        ans = [A-K, B]
    elif K <= A + B:
        ans = [0, B+A-K]
    print(*ans)
solve()
Buggy code:
ta_c,ao_c,num = map(int,input().split())

if num <= ta_c:
    print(ta_o-num,ao_c):
elif ta_c < num <= ta_c + ao_c:
    ao_c = ta_c+ao_c - num
    ta_c = 0
    print(ta_c,ao_c)
else;
    ta_c, ao_c = 0,0
    print(ta_c,ao_c)

Fixed code:
ta_c,ao_c,num = map(int,input().split())

if num <= ta_c:
    print(ta_c-num,ao_c)
elif ta_c < num <= ta_c + ao_c:
    ao_c = ta_c+ao_c - num
    ta_c = 0
    print(ta_c,ao_c)
else:
    ta_c, ao_c = 0,0
    print(ta_c,ao_c)
Buggy code:
A, B, K = map(int, input().split())
A = A - max(0, K - B)
B = max(B - K, 0)

print(str(A) + " " + str(B))

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

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

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

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

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

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



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

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

if B < 0:
    B = 0

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

Fixed code:
A, B, K = list(map(int, input().split()))
A -= K
if A < 0:
  B += A
  A = 0
if B < 0:
  B = 0
print(A, B)
Buggy code:
[a, b, k] = [int(x) for x in input().split()]

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

print(int(a),int(b))

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

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

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

Fixed code:
a,b,k = map(int,input().split())
if a>k and a>0:
    a-=k
else:
    if b>k-a and b>0:
        b-=(k-a)
    else:
        b=0
    a=0
print(str(a)+" "+str(b))
Buggy code:
a,b,k=map(int,input().split())
if k<=a:
    a-=k
elif k<=a+b:
    a=0
    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,0)
else:
    print(0,b-k+a)
Buggy code:
a,b,k = map(int,input().split())

if k > a :
  print("0",b-(k-a))
elif k=<a:
  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))
elif k == a:
  print(0, b)
elif k < a:
  print(a-k, b)
Buggy code:
a,b,k=map(int,input().split())
if k<=a:
 A=a-k
 B=b
elif k>=a and k<b:
 A=0
 B=b+a-k
else:A=B=0
print(A,B)

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:
import sys
A, B, K = map(int, input().split())

if A + B <= K:
    print(0, 0)
    sys.exit(0)
if A <= K:
    print(A-K, B)
    sys.exit(0)

print(0, A+B-K)

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

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

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

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

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

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

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