qyliang/CodeNanoFix huggingface dataset:
Buggy code:
a, b, k = input().split(' ')
a = int(a)
b = int(b)
k = int(k)

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

Fixed code:
a, b, k = input().split(' ')
a = int(a)
b = int(b)
k = int(k)
 
if (k >= a + b): print('0 0')
else:
  if (k <= a):
    print(a-k, end = ' ')
    print(b)
  else:
    print('0',end = ' ')
    print(b - k + a)
Buggy code:
# coding: utf-8
import numpy as np
from functools import lru_cache
import time

def main(): 
    if True:
        A,B,K = list(map(
            int, input().split()))
    else:
        pass

    A = A - K
    B = B if A > 0 else B + A 
    print(min(A),B)



if __name__ =='__main__':
    main()

Fixed code:
# coding: utf-8
import numpy as np
from functools import lru_cache
import time

def main(): 
    if True:
        A,B,K = list(map(
            int, input().split()))
    else:
        pass

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



if __name__ =='__main__':
    main()
Buggy code:
a,b,k = map(int, input().split())
if a <= K:
  a = 0
  k = k - a
  b -= k
  if b < 0:
    b = 0
  else:
    pass
else:
  a -= k
print(a, b)

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

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

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

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

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

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

Fixed code:
a, b, k = map(int, input().split())
if a >= k:
    print(a-k, b)
else:
    if k - a <= b:
        print(0, b-k+a)
    else:
        print(0,0)
Buggy code:
a, b, k = map(int, input().split())
if a >= k:
    a -= k
else:
    b = max(0,k - a)
    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(0,b+a-k))
Buggy code:
import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
# from collections import Counter,defaultdict,deque
# from itertools import permutations, combinations
# from heapq import heappop, heappush
# # input = sys.stdin.readline
# sys.setrecursionlimit(10**8)
# mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

a, b, k = inpm()
ta = a - k
ao = b
if(ta < 0):
    ao = b - ta
    ta = 0
if(ao < 0):
    ao = 0
print(str(ta) + ' ' + str(ao))



Fixed code:
import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
# from collections import Counter,defaultdict,deque
# from itertools import permutations, combinations
# from heapq import heappop, heappush
# # input = sys.stdin.readline
# sys.setrecursionlimit(10**8)
# mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

a, b, k = inpm()
ta = a - k
ao = b
if(ta < 0):
    ao = b + ta
    ta = 0
if(ao < 0):
    ao = 0
print(str(ta) + ' ' + str(ao))
Buggy code:
# -*- coding:utf-8 -*-

def solve():
    A, B, K = list(map(int, input().split()))

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

    print(K)


if __name__ == "__main__":
    solve()


Fixed code:
# -*- coding:utf-8 -*-

def solve():
    A, B, K = list(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)


if __name__ == "__main__":
    solve()
Buggy code:
A, B, K = map(int, input().split())
A_ = min(A, K)
print(A_, min(0, B-(K-A_)))

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

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

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

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

print(' '.join([str(a), str(b)]))

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

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

print(' '.join([str(a), str(b)]))
Buggy code:
a,b,c = map(int,input().split())
if a> c:
    print(a-c,b)
elif a+b<c:
    print("0 0")
elif a < c and c < a+b:
    print("0",a+b-c)

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

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

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

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

def eat_cookie(A,B,K):
    if A == 0 && B == 0:
        return 0,0
    if A >= K:
        return A-K,B
    else:
        if B-A+k > 0:
            return 0,B-K+A
        else:
            return 0,0


resultA,resultB = eat_cookie(A,B,K)
print(resultA,resultB)


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

def eat_cookie(A,B,K):
    if A >= K:
        return A-K,B
    else:
        if B-K+A > 0:
            return 0,B-K+A
        else:
            return 0,0


resultA,resultB = eat_cookie(A,B,K)
print(resultA,resultB)
Buggy code:
A, B, K = map(int, input().split())

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

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:
takahashi, aoki, count = map(input().split(), int)
k = count
if count - takahashi >= 0:
  takahashi -= count
else:
  takahashi = 0
  count -= takahashi
  if aoki - count > 0:
    aoki -= count
  else:
    aoki = 0
print(takahashi, aoki)

Fixed code:
takahashi, aoki, count = map(int,input().split())
k = count
if takahashi - count >= 0:
  takahashi -= count
else:
  count -= takahashi
  takahashi = 0
  if aoki - count > 0:
    aoki -= count
  else:
    aoki = 0
print(takahashi, aoki)
Buggy code:
A, B, K = list(map(int, input().split()))

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

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

aa = max(a-k, 0)
bb = max(b-max(k-a, 0), 0)
print(aa, bb)

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


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

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

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

else :
	a = a - k

print(a, b

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

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

else :
	a = a - k

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


Fixed code:
A, B, K = [int(_) for _ in 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-min(a,k),b-min(b,a-min(a,k)))

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

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

    a -= k

    if a < 0:
        return (0, b+a) if b+a > 0 else (0, 0)
    else :
        return (a, b)

def main():
    a, b, k = map(int, input().split())
    print(greedyTakahashi(a, b, k))

if __name__ == '__main__':
    main()

Fixed code:
def greedyTakahashi(a, b, k):

    a -= k

    if a < 0:
        return (0, b+a) if b+a > 0 else (0, 0)
    else :
        return (a, b)

def main():
    a, b, k = map(int, input().split())
    print(*greedyTakahashi(a, b, k))

if __name__ == '__main__':
    main()
Buggy code:
a, b, k = map(int, input().split());

a = max(0, a - k);

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

  

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

new_a = max(0, a - k);

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

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

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

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

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

Fixed code:
a,b,k = list(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 :
    print(A-K, B)
else :
    print(K-A, B+A-K)


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

if(A - K >= 0):
  A -= K
else:
  if(B+(A-K) >= 0):
    B += A - K
    A = 0
  else:
    A = 0
    B = 0
print(A, B)
Buggy code:
r=input().split()
A=int(r[0])
B=int(r[1])
K=int(r[2])
if K>=A+B:
    print("0 0")
elif K>=A:
    print("0 "+str(K-A+B))
else:
    print(str(A-K)+" "+str(B))

Fixed code:
r=input().split()
A=int(r[0])
B=int(r[1])
K=int(r[2])
if K>=A+B:
    print("0 0")
elif K>=A:
    print("0 "+str(B-K+A))
else:
    print(str(A-K)+" "+str(B))
Buggy code:
taka, aoki, action = map(int, input().split())
 
if taka >= action:
  print(taka-action, aoki)
 
else:
  print(0, max(aoki-(action-taka, 0)))

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


Fixed code:
a, b, k = [int(a) for a in input().split()]
print(a - k, b) if a >= k else print(0, b - (k - a)) if a + b - k > 0 else print(0, 0)
Buggy 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+" "+(a+b-k))

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:
  print(a-k,b)
elif a<k and b>=K:
  print(0,b-k)
else:
  print(0,0)

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

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

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

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

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

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

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

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

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

if b == 0:
    if a-k >= 0:
        print(a-k, 0)
    else:
        print(0, 0)
    sys.exit()
elif a == 0:
    if b-k >= 0:
        print(0, b-k)
    else:
        print(0, 0)
    sys.exit()
    
if a >= k:
    print(0, b -(k-a))
else:
    print(k-a, b)

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

if b == 0:
    if a-k >= 0:
        print(a-k, 0)
    else:
        print(0, 0)
    sys.exit()
elif a == 0:
    if b-k >= 0:
        print(0, b-k)
    else:
        print(0, 0)
    sys.exit()
elif a + b <= k:
    print(0, 0)
    sys.exit()
    
if a <= k:
    print(0, b -(k -a))
else:
    print(a-k, b)
Buggy code:
S=list(map(int, input().split()))
if S[2] >= S[0]+S[1]:
  print(0,0)
else S[2] >= S[0]:
  print(0,S[1]+S[0]-S[2])
else:
  print(S[0]-S[2],S[1])

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

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

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

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

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

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

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

if k < a:
  a = a-k

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

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

Fixed code:
A,B,K = list(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 = [int(s) for s in input().split()]
if K <= A:
  print(str(A-K)+' '+str(B))
else
  print(str(0)+' '+str(A+B-K))

Fixed code:
A, B, K = [int(s) for s in input().split()]
X = A+B
if K <= A:
  print(str(A-K)+' '+str(B))
elif K <= X:
  print(str(0)+' '+str(X-K))
else:
  print(str(0)+' '+str(0))
Buggy code:
a,b,k=map(int,input().split())

if a>= k:
    a=a-k
else:
    dif=k-a
    a=0    
    print(dif)
    b=b-dif
    if b<0:
        b=0
print("{0} {1}".format(a,b))


Fixed code:
a,b,k=map(int,input().split())
takahashi=0
if a>= k:
    #a=a-k
    takahashi=a-k
else:
    dif=k-a
    takahashi=0    
    #print(dif)
    b=b-dif
    if b<0:
        b=0
print("{0} {1}".format(takahashi,b))
Buggy code:
a,b,k = map(int,input().split())
if a+b <= k:
    print("0 0")
    exit()
if a <= k:
    a = 0
    b = b - k + a
    print(a,b)
else:
    print(a-k,b)

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

t = t-k
if t<0:
  a -= t
  t = 0
if a<0:
  a = 0
print(t,a)

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

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

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

print(A, B)


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

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

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

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

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

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

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

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

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

Fixed code:
a,b,c=map(int,input().split())
if a >= c:
  print(a-c,b)
else:
  print(0,max(a+b-c,0))
Buggy code:
s=input().split()
i=int(s[0])
j=int(s[1])
k=int(s[2])
if k>=i:
  i=0
  j=j-k+i
else:
  i=i-k
print(str(i)+" "str(j))

Fixed code:
s=input().split()
i=int(s[0])
j=int(s[1])
k=int(s[2])
if k>=i:
  j=j-(k-i)
  i=0
  if j<0:
    j=0
else:
  i=i-k
print(str(i)+" "+str(j))
Buggy code:
a = input().rstrip().split(' ')
b=[int(i) for i in a]
print(b)
S,T,U=b[0],b[1],b[2]
if S>U:
    S1=S-U
    print(S1,T)
elif S==U:
    print(0,T)
elif S<U and S+T>U:
    U1=U-S
    T1=T-U1
    print(0,T1)
else:
    print(0,0)

Fixed code:
a = input().rstrip().split(' ')
b=[int(i) for i in a]
S,T,U=b[0],b[1],b[2]
if S>U:
    S1=S-U
    print(S1,T)
elif S==U:
    print(0,T)
elif S<U and S+T>U:
    U1=U-S
    T1=T-U1
    print(0,T1)
else:
    print(0,0)
Buggy code:
a, b, k = map(int, input().split())

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

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

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

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


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

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

print(A, B)

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

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

print(A, B)
Buggy code:

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

Fixed code:

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

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

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

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

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

c = a - k


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

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

c = a - k


if c >= 0:
  print(c, b)
else:
  d = b + c
  if d >= 0:
    print(0, d)
  else:
    print(0, 0)
Buggy code:
a, b, k = list(map(int,input().strip().split(' ')))

if a > k:
    a1 = a - k
    b1 = b

elif b > k - a:
    a1 = 0
    b1 = max(b -(k - a),0)
    
print(a1, b1)

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

if a > k:
    a1 = a - k
    b1 = b

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

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

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