ZhenlongDai/ACPR huggingface dataset:
Problem: p02818
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b,k = map(int,input().split())
if a>k:
  print(a-k)
elif a+b>k:
  print((a+b)-k)
else:
  print(0)

Failing test case input:
362104 16911655 0000000111100

Expected output:
251004 16911655


Actual output:
251004


Fixed submission (verdict: Accepted):
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)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B ,K = list(map(int, input().split()))
if A > K:
  print(A-K, B)
else:
  b = B-(K-A) if B>(K-A) else "0"
  print(0, B-(K-A))

Failing test case input:
0 -1 2

Expected output:
0 0


Actual output:
0 -3


Fixed submission (verdict: Accepted):
A, B ,K = list(map(int, input().split()))
if A > K:
  print(A-K, B)
else:
  b = B-(K-A) if B>(K-A) else "0"
  print(0, b)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, K = map(int, input().split())
print(max(A - K, 0), min(A + B - K, B))


Failing test case input:
223869749260 13514692621 1010010101011

Expected output:
0 0


Actual output:
0 -772625659130


Fixed submission (verdict: Accepted):
A, B, K = map(int, input().split())
print(max(A - K, 0), max(min(A + B - K, B), 0))

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, K = (int(i) for i in input().split())

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

Failing test case input:
623031139973 53371298929 0000010100000

Expected output:
623021039973 53371298929


Actual output:
623021039973


Fixed submission (verdict: Accepted):
A, B, K = (int(i) for i in input().split())

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

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, K = map(int, input().split())

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

Failing test case input:
500000000000 500000000000 1000000000000

Expected output:
0 0

Actual output:

Fixed submission (verdict: Accepted):
A, B, K = map(int, input().split())

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

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, k = map(int, input().split())
c = a+b-k
if c > b:
    print(c-b, b)
else:
    print(0, c)

Failing test case input:
-1 0 1

Expected output:
0 0


Actual output:
0 -2


Fixed submission (verdict: Accepted):
a, b, k = map(int, input().split())
c = a+b-k
if c > b:
    print(c-b, b)
else:
    print(0, max(0,c))
Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys
a, b, k = map(int, sys.stdin.readline().split())
if a < k:
  print(0, a + b - k)
else:
  print(a - k, b)

Failing test case input:
7578113331 581054487 0010110110000

Expected output:
0 0


Actual output:
0 -1950942182


Fixed submission (verdict: Accepted):
import sys
a, b, k = map(int, sys.stdin.readline().split())
if a < k:
  if a + b - k >= 0:
    print(0, a + b - k)
  else:
    print(0, 0)
else:
  print(a - k, b)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, k=map(int, input().split())
if a>=k:
  print(a-k, b)
else:
  print(0, a+b-k)

Failing test case input:
223869749260 13514692621 1010010100011

Expected output:
0 0


Actual output:
0 -772625658130


Fixed submission (verdict: Accepted):
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)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k = map(int,input().split())

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

Failing test case input:
-1 0 0

Expected output:
0 0


Actual output:
0 -1


Fixed submission (verdict: Accepted):
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)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
inpt = input()

inpt = inpt.split(" ")
inpt = [int(i) for i in inpt]

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



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

print(A,B)


Failing test case input:
9875757521 933260677 0010110110000

Expected output:
0 698908198


Actual output:
0 0


Fixed submission (verdict: Accepted):
inpt = input()
 
inpt = inpt.split(" ")
inpt = [int(i) for i in inpt]
 
A = inpt[0]
B = inpt[1]
K = inpt[2]
 
if A >= K:
  A = A - K
else:
  K = K - A
  A = 0
  B = max(0,B - K)

print(A,B)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)

Failing test case input:
498881727339 49011419508 0000001100000

Expected output:
498880627339 49011419508


Actual output:
498881727339 49011419508 1100000
498880627339 49011419508


Fixed submission (verdict: Accepted):
A,B,K=map(int,input().split())
if A+B<=K:
    print(0,0)
elif K>=A:
    print(0,B-K+A)
else:
    print(A-K,B)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k=map(int,input().split())
 
if a<=k:
    k=k-a
    a=0
    print(a,b-k)
else:
    a=a-k
    print(a,b)

Failing test case input:
46282745761 3894888655 1010010100011

Expected output:
0 0


Actual output:
0 -959832465595


Fixed submission (verdict: Accepted):
a,b,k=map(int,input().split())
 
if a+b<k:
    print(0,0)
    exit()

if a<=k:
    k=k-a
    a=0
    print(a,b-k)
else:
    a=a-k
    print(a,b)
Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)

Failing test case input:
9875757521 933260677 0010110110000

Expected output:
0 698908198


Actual output:
0 0


Fixed submission (verdict: Accepted):
a, b, k = map(int, input().split())

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

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,K=map(int,input().split())
q=str(max(A-K,0))
if A>=K:
  w=B
else:
  w=str(B-K+A)
print(q,w)

Failing test case input:
-1 0 0

Expected output:
0 0


Actual output:
0 -1


Fixed submission (verdict: Accepted):
A,B,K=map(int,input().split())
q=str(max(A-K,0))
if A+B<=K:
  print("0 0")
else:
  if A>=K:
    w=B
  else:
    w=str(B-K+A)
  print(q,w)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)

Failing test case input:
498881727339 92988479429 1010000000000

Expected output:
0 0


Actual output:
[0, 0]


Fixed submission (verdict: Accepted):
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])

Problem: p02818
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a, b, k = map(int, input().split())
a1, a2 = 0, 0

if(k >= a):
    a1=0
    a2 = b - (k-a)
else:
    a1 = a-k
    a2 = b

print(a1, a2)


Failing test case input:
46282745761 933260677 1010010100001

Expected output:
0 0


Actual output:
0 -962794093563


Fixed submission (verdict: Accepted):
def minas2zero(n):
    if(n<=0):return 0
    return n
a, b, k = map(int, input().split())
a1, a2 = 0, 0
if(k >= a):
    a1 = 0
    a2 = minas2zero(b - (k-a))
else:
    a1 = a-k
    a2 = b

print(a1, a2)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k = map(int,input().split())

ans_a = 0
ans_b = 0
ans_a = max(0,a-k)

if( ans_a == 0):
    ans_b = max(0, b-(k-a))


print("{0} {1}".format(ans_a,ans_b))
    

Failing test case input:
623031139973 53371298929 0000010100000

Expected output:
623021039973 53371298929


Actual output:
623021039973 0


Fixed submission (verdict: Accepted):
a,b,k = map(int,input().split())

ans_a = 0
ans_b = b
ans_a = max(0,a-k)

if( ans_a == 0):
    ans_b = max(0, b-(k-a))


print("{0} {1}".format(ans_a,ans_b))

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k=map(int,input().split())
if a>k:
  t=a-k
  s=b
else:
  t=0
  s=b-k+a
print(str(t)+' '+str(s))

Failing test case input:
250272688906 3894888655 1010010100011

Expected output:
0 0


Actual output:
0 -755842522450


Fixed submission (verdict: Accepted):
a,b,k=map(int,input().split())
if a>k:
  t=a-k
  s=b
else:
  t=0
  s=max(b-k+a,0)
print(str(t)+' '+str(s))
Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, k = map(int, input().split())
print(max(0, a-k), b - max(0, k-a))


Failing test case input:
9875757521 933260677 1010110110000

Expected output:
0 0


Actual output:
0 -999301091802


Fixed submission (verdict: Accepted):
a, b, k = map(int, input().split())
print(max(0, a-k), max(0, b - max(0, k-a)))

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, k = map(int, input().split())

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

Failing test case input:
18064166595 581054487 0010110110001

Expected output:
7954056594 581054487


Actual output:
-7954056594 581054487


Fixed submission (verdict: Accepted):
a, b, k = map(int, input().split())
if k < a:
    print(a - k, b)
else:
    r = k - a
    print(0, 0 if b - r <= 0 else b-r)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

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

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

Failing test case input:
24844196728 933260677 1010010100001

Expected output:
0 0


Actual output:
0 -984232642596


Fixed submission (verdict: Accepted):
A, B, K = map(int, input().split())

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

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b ,k = map(int, input().split())

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

Failing test case input:
878339967763 559952381 0010010101101

Expected output:
868329866662 559952381


Actual output:
868329866662 0


Fixed submission (verdict: Accepted):
a, b ,k = map(int, input().split())

if a > k:
    a = a - k
elif a > k and k <= a+b:
    fa = abs(a-k)
    a = 0
    b = b - fa
else:
    fa = abs(a-k)
    a = 0
    b = b - fa
    if b < 0:
        b = 0

print(a, b)

Problem: p02818
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
from sys import stdout
printn = lambda x: stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
DBG = True 
BIG = 999999999
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

a,b,k = inm()
print("{} {}".format(max(0,a-k), b-max(0,k-a)))


Failing test case input:
46282745761 933260677 1010010100011

Expected output:
0 0


Actual output:
0 -962794093573


Fixed submission (verdict: Accepted):
from sys import stdout
printn = lambda x: stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
DBG = True 
BIG = 999999999
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

a,b,k = inm()
print("{} {}".format(max(0,a-k), max(0,b-max(0,k-a))))
Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

import sys
sys.setrecursionlimit(10000000)
INF = 1<<32


def solve(A: int, B: int, K: int):
    t = max(0, A-K)
    a = B
    if A-K > 0:
        a = B
    else:
        a -= max(0, K-A)

    print(t, a)
    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))  
    K = int(next(tokens))  
    solve(A, B, K)

if __name__ == '__main__':
    main()


Failing test case input:
498881727339 92988479429 1000000000000

Expected output:
0 0


Actual output:
0 -408129793232


Fixed submission (verdict: Accepted):

import sys
sys.setrecursionlimit(10000000)
INF = 1<<32


def solve(A: int, B: int, K: int):
    t = max(0, A-K)
    a = B
    if A-K > 0:
        a = B
    else:
        a = max(0, a- (K-A))

    print(t, a)
    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))  
    K = int(next(tokens))  
    solve(A, B, K)

if __name__ == '__main__':
    main()

Problem: p02818
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A, B, K = map(int, input().split())

A_after = A
B_after = B

A_after = A - K

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

Failing test case input:
0 -1 2

Expected output:
0 0


Actual output:
0 -3


Fixed submission (verdict: Accepted):
A, B, K = map(int, input().split())

A_after = 0
B_after = 0

if A - K >= 0:
  A_after = A - K
  B_after = B

elif A + B - K >= 0:
  B_after = B - (K - A)
  
print(A_after, B_after)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k=map(int,input().split())
print(max(a-k,0),max(b+(a-k),0))
    
    
    

Failing test case input:
488984103352 24648370780 0000010100000

Expected output:
488974003352 24648370780


Actual output:
488974003352 513622374132


Fixed submission (verdict: Accepted):
a,b,k=map(int,input().split())
print(max(a-k,0),max(b+min(a-k,0),0))

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k=map(int,input().split())
if a>=k:
  print(a-k,b)
else:
  print(0,b-(k-a))

Failing test case input:
24844196728 933260677 1010110100001

Expected output:
0 0


Actual output:
0 -984332642596


Fixed submission (verdict: Accepted):
a,b,k=map(int,input().split())
if a>k:
  print(a-k,b)
else:
  print(0,max(b-(k-a),0))

Problem: p02818
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
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)

Failing test case input:
2 3 2

Expected output:
0 3


Actual output:
0 1


Fixed submission (verdict: Accepted):
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)
Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=[int(i) for i in input().split()]

if a[0]<a[2] and a[1]>=a[2]-a[0]:
    print(0,a[1]-a[2]+a[0])
elif a[0]>=a[2]:
    print(a[2]-a[0],a[1])

Failing test case input:
8901212864 933260677 1110110100001

Expected output:
0 0


Actual output:

Fixed submission (verdict: Accepted):
a=[int(i) for i in input().split()]
if a[0]+a[1]<=a[2]:
    print(0,0)
else:
    if a[0]<=a[2]:
        print(0,a[1]-(a[2]-a[0]))
    elif a[0]>a[2]:
        print(a[0]-a[2],a[1])

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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
print(A,B)


Failing test case input:
8 6 0

Expected output:
8 6


Actual output:
8 -2


Fixed submission (verdict: Accepted):
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)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)
  
  


Failing test case input:
9875757521 933260677 1110110100000

Expected output:
0 0


Actual output:
0 -1099301081802


Fixed submission (verdict: Accepted):
a,b,k=map(int,input().split())
if a>=k:
  print(a-k,b)
  
else:
  print(0,max(0,a+b-k))

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, K = map(int, input().split())

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

Failing test case input:
46282745761 1953749145 1010010100011

Expected output:
0 0


Actual output:
0 -1008056350866


Fixed submission (verdict: Accepted):
A, B, K = map(int, input().split())

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

print(A, B)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k=map(int,input().split())
if a>=k:
    print(a-k,b)
else:
    print(0,b-k+a)

Failing test case input:
223869749260 13514692621 1010010101011

Expected output:
0 0


Actual output:
0 -772625659130


Fixed submission (verdict: Accepted):
a,b,k=map(int,input().split())
if a>=k:
    print(a-k,b)
else:
    print(0,max(b-k+a,0))

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def main():
    a, b, k = map(int, input().split())
    if a <= k:
        a_diff = k - a
        a = 0
        b -= a_diff
        print(a, b)
    else:
        a = a - k
        print(a, b)


if __name__ == "__main__":
    main()


Failing test case input:
250272688906 5812721198 1010010100011

Expected output:
0 0


Actual output:
0 -753924689907


Fixed submission (verdict: Accepted):
def main():
    a, b, k = map(int, input().split())
    if a == 0 and b == 0:
        print(a, b)
    elif a <= k:
        a_diff = k - a
        a = 0
        if b <= a_diff:
            b = 0
            print(a, b)
        else:
            b -= a_diff
            print(a, b)
    else:
        a = a - k
        print(a, b)


if __name__ == "__main__":
    main()
Problem: p02818
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a, b, k = map(int, input().split())
if k >= a:
    b -= k-a
    a = 0
else:
    a = a-k
print(a, b)


Failing test case input:
223869749260 13514692621 1010010101011

Expected output:
0 0


Actual output:
0 -772625659130


Fixed submission (verdict: Accepted):
a, b, k = map(int, input().split())
if k >= a:
    b -= k-a
    a = 0
else:
    a -= k
print(max(a, 0), max(b, 0))

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)

Failing test case input:
143395449423 9468746842 1010010100011

Expected output:
0 0


Actual output:
143395449423 9468746842


Fixed submission (verdict: Accepted):
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)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, K = map(int, input().split())
if A > K:
    print(A-K, B)
if A == K:
    print(0, B)
if A < K:
    print(0, B - (K - A))

Failing test case input:
4188594464 581054487 0010110110001

Expected output:
0 0


Actual output:
0 -5340461050


Fixed submission (verdict: Accepted):
A, B, K = map(int, input().split())
if A > K:
    print(A-K, B)
if A == K:
    print(0, B)
if (A < K) and (A + B > K) :
    print(0, B - (K - A))
if (A < K) and (A + B <= K) :
    print(0, 0)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

def main()->None:
    A, B, K = map(int, input().split())
    range_K = range(K)
    
    diff = B - A
    if diff > 0:
        print(0, B-diff)
    else:
        print(0,0)





if __name__ == "__main__":
    main()

Failing test case input:
40795666163 581054487 0010010100001

Expected output:
30785566162 581054487


Actual output:
0 0


Fixed submission (verdict: Accepted):

def main()->None:
    A, B, K = map(int, input().split())

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





if __name__ == "__main__":
    main()

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, k = map(int , input().split())





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

Failing test case input:
-1 0 1

Expected output:
0 0


Actual output:
0 2


Fixed submission (verdict: Accepted):
a, b, k = map(int , input().split())





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

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, K = map(int, input().split())
print(max(A - K, 0), B - max(K - A, 0))


Failing test case input:
82916368507 3894888655 1010010100011

Expected output:
0 0


Actual output:
0 -923198842849


Fixed submission (verdict: Accepted):
A, B, K = map(int, input().split())
print(max(A - K, 0), max(B - max(K - A, 0), 0))
Problem: p02818
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A, B, K = map(int, input().split())
if A >= K:
    A = A-K
else:
    B=B-(K-A)
    A=0

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

Failing test case input:
223869749260 13514692621 1010010100011

Expected output:
0 0


Actual output:
0 -772625658130


Fixed submission (verdict: Accepted):
A, B, K = map(int, input().split())
if A >= K:
    A = A - K
else:
    B = B - (K - A)
    A = 0
    if B < 0:
        B = 0

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

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, K = map(int, input().split())
if A>=K:
    print(A-K, B)
else:
    print(0, B-(K-A))

Failing test case input:
498881727339 49011419508 1000000100000

Expected output:
0 0


Actual output:
0 -452106953153


Fixed submission (verdict: Accepted):
A, B, K = map(int, input().split())
if A>=K:
    print(A-K, B)
else:
    print(0, max(0, B-(K-A)))

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, K = map(int, input().split())

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


Failing test case input:
8901212864 933260677 1110110100001

Expected output:
0 0


Actual output:
0 -1100275626460


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

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

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

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

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

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


Failing test case input:
8901212864 933260677 1110010100001

Expected output:
0 0


Actual output:
1101108887137 -1100175626460


Fixed submission (verdict: Accepted):
A, B, K = map(int, input().split())

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

Problem: p02818
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b,k = [int(x) for x in input().split()]
if a >= k:
  print(a-k,b)
else:
  print(0,a+b-k)

Failing test case input:
82916368507 3894888655 1010010100011

Expected output:
0 0


Actual output:
0 -923198842849


Fixed submission (verdict: Accepted):
a,b,k = [int(x) for x in input().split()]
if a > k:
  print(a-k,b)
else:
  print(0,max(0,a+b-k))

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k=map(int,input().split())
print((a-k,b) if a>k else (0,b-k+a) if a+b>k else (0,0))

Failing test case input:
1547869 73650225 0000000111100

Expected output:
1436769 73650225


Actual output:
(1436769, 73650225)


Fixed submission (verdict: Accepted):
a,b,k=map(int,input().split())
print(a-k if a>k else 0,b if a>k else a+b-k if a+b>k else 0)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,K = map(int,input().split())

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


Failing test case input:
-1 0 0

Expected output:
0 0


Actual output:
0 -1


Fixed submission (verdict: Accepted):
A,B,K = map(int,input().split())

if A >= K:
    print(A-K,B)
else:
    print(0,max(0,A+B-K))
Problem: p02818
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
T,A,K = map(int,input().split())
sta = T + A - K
if sta <= 0:
    print("0 0")
elif sta >= A:
    print(str(T-sta +A) +" "+str(A))
else:
    print("0 " + str(sta))

Failing test case input:
4 6 0

Expected output:
4 6


Actual output:
0 6


Fixed submission (verdict: Accepted):
T,A,K = map(int,input().split())
sta = T + A - K
if sta <= 0:
    print("0 0")
elif sta >= A:
    print(str(T-K) +" "+str(A))
else:
    print("0 " + str(sta))

Problem: p02818
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b,k = map(int, input().split())
if a <= k:
    print(0,b-(k-a))
else:
    print(a-k,b)

Failing test case input:
125508515642 3894888655 1010010100011

Expected output:
0 0


Actual output:
0 -880606695714


Fixed submission (verdict: Accepted):
a,b,k = map(int, input().split())
if a <= k:
    print(0,max(b-(k-a),0))
else:
    print(a-k,b)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, k = map(int , input().split())





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

Failing test case input:
46282745761 933260677 1010010100011

Expected output:
0 0


Actual output:
0 962794093573


Fixed submission (verdict: Accepted):
a, b, k = map(int , input().split())





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

Problem: p02818
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
A,B,K = list(map(int,input().split()))

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

Failing test case input:
7578113331 933260677 0010110110000

Expected output:
0 0


Actual output:
0


Fixed submission (verdict: Accepted):
A,B,K = list(map(int,input().split()))
 
if K<=A:
    print(A-K,B)
elif K<=A+B:
    print(0,B+A-K)
else:
    print(0,0)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, k = map(int, input().split())
if a >= k:
    a-=k
else:
    k = k-a
    a = 0
    b -=k
print(a, b)


Failing test case input:
223869749260 13514692621 1011010101111

Expected output:
0 0


Actual output:
0 -773625659230


Fixed submission (verdict: Accepted):
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)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,K=map(int,input().split())
print(max(0,A-K),max(0,B-(K-A)))

Failing test case input:
22565061889 581054487 0010010110001

Expected output:
12554951888 581054487


Actual output:
12554951888 13136006375


Fixed submission (verdict: Accepted):
A,B,K=map(int,input().split())
print(max(0,A-K),max(0,B-(max(K-A, 0))))
Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k = map(int,input().split())
print(" ".join(map(str,[max(0,a-k),max(0,a+b-k)])))


Failing test case input:
1485644197907 516416634 0010010100001

Expected output:
1475634097906 516416634


Actual output:
1475634097906 1476150514540


Fixed submission (verdict: Accepted):
a,b,k = map(int,input().split())
print(" ".join(map(str,[max(0,a-k),max(0,b-max(0,k-a))])))

Problem: p02818
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
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))

Failing test case input:
7578113331 933260677 0010110110000

Expected output:
0 0


Actual output:
0 -9176849323


Fixed submission (verdict: Accepted):
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))

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, K = map(int, input().split())
if A>=K:
    A = A - K
elif A<K  and B>K-A:
    A = 0
    B = B -(K-A)
else:
    A = B = 0
print(A, B, sep=' ')

Failing test case input:
9875757521 933260677 0010110110000

Expected output:
0 698908198


Actual output:
0 -9176849323


Fixed submission (verdict: Accepted):
A, B, K = map(int, input().split())
if A>=K:
    A = A - K
    print(A,B)
else:
    K -= A
    A = 0
    B = max(0,B-K)
    print(A,B)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int,input().split())
if a<=c:
  print(max(a+b-c,0))
else:
  print(a-c)

Failing test case input:
24844196728 933260677 1010110100001

Expected output:
0 0


Actual output:
0


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split())
if a<=c:
  print(0,max(a+b-c,0))
else:
  print(a-c,b)

Problem: p02818
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b,k=map(int,input().split())
if a>=k:
  print(k-a,b)
elif a<k and b-(k-a)>0:
  print(0,b-(k-a))
else:
  print(0,0)

Failing test case input:
1138880556104 559952381 0010010101101

Expected output:
1128870455003 559952381


Actual output:
-1128870455003 559952381


Fixed submission (verdict: Accepted):
a,b,k=map(int,input().split())
if k>=a+b:
  print(0,0)
elif a>=k:
  print(a-k,b)
else:
  print(0,b-(k-a))

Problem: p02818
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a,b,k = map(int,input().split())


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


Failing test case input:
24844196728 933260677 1010010100001

Expected output:
0 0


Actual output:
0 -984232642596


Fixed submission (verdict: Accepted):
a,b,k = map(int,input().split())

if k > a:
    b = b - (k-a)
a = max((a-k,0))
b = max((b,0))
print(a,b)
Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k=map(int,input().split())

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

Failing test case input:
1138880556104 516416634 0010010101101

Expected output:
1128870455003 516416634


Actual output:
1128870455003 0


Fixed submission (verdict: Accepted):

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

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

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k=map(int,input().split())
if a>=k:
  a=a-k
else:
  b=b-(k-a)
  a=0
print("{} {}".format(a,b))

Failing test case input:
8901212864 933260677 1110110100001

Expected output:
0 0


Actual output:
0 -1100275626460


Fixed submission (verdict: Accepted):
a,b,k=map(int,input().split())
if a>=k:
  a=a-k
else:
  b=b-(k-a)
  a=0
b=max(0,b)
print("{} {}".format(a,b))

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,K=map(int,input().split())
ans=[0]*2

if A>=K:
  ans[0]=A-K
  ans[1]=B
else:
  ans[1]=B-(K-A)

print(ans[0],ans[1])

Failing test case input:
9957043226 933260677 1110010100001

Expected output:
0 0


Actual output:
0 -1099119796098


Fixed submission (verdict: Accepted):
A,B,K=map(int,input().split())
ans=[0]*2

if A>=K:
  ans[0]=A-K
  ans[1]=B
else:
  ans[1]=max(0,B-(K-A))

print(ans[0],ans[1])

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k=map(int,input().split())
if k-a>0:
    print("0",b-k+a)
else:
    print(a-k,b)

Failing test case input:
46282745761 933260677 1010010100001

Expected output:
0 0


Actual output:
0 -962794093563


Fixed submission (verdict: Accepted):
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)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)


Failing test case input:
2 3 3

Expected output:
0 2

Actual output:
0 0


Fixed submission (verdict: Accepted):
A,B,K = map(int,input().split())

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

print(A,B)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, k = map(int, input().split())
print(max(a - k, 0), b - max(k - a, 0))


Failing test case input:
7578113331 581054487 0010110110001

Expected output:
0 0


Actual output:
0 -1950942183


Fixed submission (verdict: Accepted):
a, b, k = map(int, input().split())
print(max(a - k, 0), max(b - max(k - a, 0), 0))
Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, k = map(int, input().split())

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

print(a, b)

Failing test case input:
551061056476 2744039490 0000010100100

Expected output:
551050956376 2744039490


Actual output:
-551050956376 2744039490


Fixed submission (verdict: Accepted):
a, b, k = map(int, input().split())

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

print(a, b)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k = input().split()
a = int(a)
b = int(b)
k = int(k)
if k - a > 0 and k - (a + b) > 0:
    print(0, 0)
elif k - a > 0 and k - (a + b) < 0:
    print(0, (a+b)-k)
else:
    print(a-k, b)


Failing test case input:
500000000000 500000000000 1000000000000

Expected output:
0 0

Actual output:
-500000000000 500000000000


Fixed submission (verdict: Accepted):
a,b,k = input().split()
a = int(a)
b = int(b)
k = int(k)
if a >= k:
    print(a-k, b)
elif a < k  and b+a-k >=0 :
    print(0, b+a-k)
else:
    print(0, 0)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k=map(int, input().split())

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

Failing test case input:
498881727339 49011419508 1000000100000

Expected output:
0 0


Actual output:
0 -452106953153


Fixed submission (verdict: Accepted):
a,b,k=map(int, input().split())

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

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k=map(int,input().split())
if a>=k:
    print(a-k,b)
else:
    print(0,b-k+a)
    

Failing test case input:
283244830608 274588616851 1000000000000

Expected output:
0 0


Actual output:
0 -442166552541


Fixed submission (verdict: Accepted):
a,b,k=map(int,input().split())
if a+b>=k:
    if a>=k:
        print(a-k,b)
    else:
        print(0,a+b-k)
else:
    print(0,0)

Problem: p02818
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
A,B,K = map(int,input().split())

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

else:
    print(0,B-(K-A))

Failing test case input:
7578113331 581054487 0010110110001

Expected output:
0 0


Actual output:
0 -1950942183


Fixed submission (verdict: Accepted):
A,B,K = map(int,input().split())

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

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

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k=map(int,input().split())
print(max(a-k,0), min(b, a+b-k))

Failing test case input:
283244830608 274588616851 1000000000000

Expected output:
0 0


Actual output:
0 -442166552541


Fixed submission (verdict: Accepted):
a,b,k=map(int,input().split())
print(max(a-k,0), max(0, min(b, a+b-k)))
Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, k = map(int, input().split())

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

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

elif k < a:
    print(a-k, b)



Failing test case input:
8901212864 933260677 1110110100001

Expected output:
0 0


Actual output:
0 -1100275626460


Fixed submission (verdict: Accepted):
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:
    a = 0
    print(a, b)

elif k < a:
    print(a-k, b)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)

Failing test case input:
9875757521 933260677 0010110110000

Expected output:
0 698908198


Actual output:
0 0


Fixed submission (verdict: Accepted):
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)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


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

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


Failing test case input:
9875757521 933260677 0010110110000

Expected output:
0 698908198


Actual output:
0 0


Fixed submission (verdict: Accepted):


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)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, K = map(int, input().split())

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

Failing test case input:
9875757521 933260677 0010110110000

Expected output:
0 698908198


Actual output:
0 0


Fixed submission (verdict: Accepted):
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)

Problem: p02818
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
import sys
sys.setrecursionlimit(10**9)
INF=10**18
def input():
    return sys.stdin.readline().rstrip()

def main():
    A,B,K=map(int,input().split())
    ans=A-K if A-K>0 else 0
    ans2=B-(K-A if K-A >0 else 0)
    print(str(ans)+' '+str(ans2))

if __name__ == '__main__':
    main()


Failing test case input:
7578113331 933260677 0010110110000

Expected output:
0 0


Actual output:
0 -1598735992


Fixed submission (verdict: Accepted):
import sys
sys.setrecursionlimit(10**9)
INF=10**18
def input():
    return sys.stdin.readline().rstrip()

def main():
    A,B,K=map(int,input().split())
    ans=A-K if A-K>0 else 0
    ans2=B-(K-A if K-A >0 else 0)
    ans2=ans2 if ans2>0 else 0
    print(str(ans)+' '+str(ans2))

if __name__ == '__main__':
    main()
Problem: p02818
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
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)

Failing test case input:
551061056476 2744039490 0000010100000

Expected output:
551050956476 2744039490


Actual output:
0 553794995966


Fixed submission (verdict: Accepted):
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)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = map(int, input().split())
if a >= c:
  a -= c
  print(a,b)
elif a < c:
  b -= (c-a)
  a = 0
  print(a,b)
    

Failing test case input:
24844196728 933260677 1010110100001

Expected output:
0 0


Actual output:
0 -984332642596


Fixed submission (verdict: Accepted):
a,b,c = map(int, input().split())
if a >= c:
  a -= c
  print(a,b)
elif c-a < b:
  b -= (c-a)
  a = 0
  print(a,b)
else:
  print(0,0)

Problem: p02818
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A,B,K = map(int,input().split())

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

else:
    A -= K

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

Failing test case input:
7578113331 933260677 0010110110000

Expected output:
0 0


Actual output:
-2531996669 933260677


Fixed submission (verdict: Accepted):
A,B,K = map(int,input().split())

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

else:
    A -= K

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

Problem: p02818
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
import sys
A, B, K = map(int, input().split())

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

print(0, A+B-K)

Failing test case input:
204065 73650225 0000000111100

Expected output:
92965 73650225


Actual output:
0 73743190


Fixed submission (verdict: Accepted):
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)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,K = map(int, input().split())
B = (B - (K-A))
A = (A - K)
if B < 0:
  B = 0
if A < 0:
  A = 0
print(A, B)

Failing test case input:
1138880556104 516416634 0010010101101

Expected output:
1128870455003 516416634


Actual output:
1128870455003 1129386871637


Fixed submission (verdict: Accepted):
A,B,K = map(int, input().split())
if (A-K) < 0:
  K = (K-A)
  A = 0
else:
  A = A - K
  K = 0
if (B-K) < 0:
  B = 0
else:
  B = B - K
print(A, B)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, K = (int(i) for i in input().split())

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

print(a, b)

Failing test case input:
637172716773 516416634 0010010101101

Expected output:
627162615672 516416634


Actual output:
627162615672 627679032306


Fixed submission (verdict: Accepted):
A, B, K = (int(i) for i in input().split())

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

print(a, b)
Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, k = map(int,input().split())
k = k - a
if k >= 0:
    b = b - k
    print(0,b)
else:
    print(-k,b)


Failing test case input:
13071060683 933260677 1010110100001

Expected output:
0 0


Actual output:
0 -996105778641


Fixed submission (verdict: Accepted):
a, b, k = map(int,input().split())
k = k - a
if k >= 0:
    b = b - k
    if b >= 0:
        print(0,b)
    else:
        print(0,0)
else:
    print(-k,b)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k = [int(i) for i in input().split()]
 
if a + b >= k:
  print(0,0)
elif k >= a:
  print(0, b - (k-a))
else:
  print(a-k,b)

Failing test case input:
223869749260 9468746842 1010010100011

Expected output:
0 0


Actual output:
0 -776671603909


Fixed submission (verdict: Accepted):
a,b,k = [int(i) for i in input().split()]
 
if a + b <= k:
  print(0,0)
elif k >= a:
  print(0, b - (k-a))
else:
  print(a-k,b)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, k = map(int, input().split())
if k >= a:
    b = b - (k - a)
    a = 0
else:
    a -= k
print(a, b)


Failing test case input:
223869749260 13514692621 1010010100011

Expected output:
0 0


Actual output:
0 -772625658130


Fixed submission (verdict: Accepted):
a, b, k = map(int, input().split())
if k >= a:
    b = b - (k - a)
    if b <= 0: b = 0
    a = 0
else:
    a -= k
print(a, b)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, K = [int(i) for i in input().split()]

a = max(A - K, 0)
k = max(K - A, 0)
b = B - k
print(str(a) + ' ' + str(b))


Failing test case input:
8901212864 933260677 1110110100001

Expected output:
0 0


Actual output:
0 -1100275626460


Fixed submission (verdict: Accepted):
A, B, K = [int(i) for i in input().split()]

a = max(A - K, 0)
k = max(K - A, 0)
b = max(B - k, 0)
print(str(a) + ' ' + str(b))

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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))

Failing test case input:
9875757521 933260677 0010110110000

Expected output:
0 698908198


Actual output:
0 0


Fixed submission (verdict: Accepted):
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))

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, k = map(int, input().split(" "))

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

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

Failing test case input:
488984103352 28853843669 0000010100000

Expected output:
488974003352 28853843669


Actual output:

Fixed submission (verdict: Accepted):
from sys import exit
a, b, k = map(int, input().split(" "))


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

if a <= 0:
    b += a
    a = 0
print(a, b)
Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k=map(int,input().split())
print(max(a-k,0),b-max(k-a,0))

Failing test case input:
9875757521 933260677 1010110100000

Expected output:
0 0


Actual output:
0 -999301081802


Fixed submission (verdict: Accepted):
a,b,k=map(int,input().split())
print(max(a-k,0),max(0,b-max(k-a,0)) )

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, k = map(int, input().split(" "))

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

print(a, b)

Failing test case input:
9957043226 933260677 1110010100001

Expected output:
0 0


Actual output:
0 -1099119796098


Fixed submission (verdict: Accepted):
a, b, k = map(int, input().split(" "))
 
if a >= k:
  a -= k
else:
  a -= k
  b += a
  if b < 0:
    b = 0
  a = 0
 
print(a, b)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, K = map(int, input().split())

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

elif A<K and K-A>B:
    print(0,0)

Failing test case input:
8901212864 933260677 1110110100001

Expected output:
0 0


Actual output:
0 -1100275626460


Fixed submission (verdict: Accepted):
A, B, K = map(int, input().split())

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

elif A<K and K-A>B:
    print(0,0)
else:
    print(0,0)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)

Failing test case input:
46282745761 3894888655 1010010100011

Expected output:
0 0


Actual output:
0 967622242905


Fixed submission (verdict: Accepted):
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)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k = map(int,input().split())
A = max(a-k,0)
B = max(b-k+a,0)
print(A,B)

Failing test case input:
551061056476 11555398095 0000010100000

Expected output:
551050956476 11555398095


Actual output:
551050956476 562606354571


Fixed submission (verdict: Accepted):
a,b,k = map(int,input().split())
A = max(a-k,0)
B = max(b-max(k-a,0),0)
print(A,B)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,k = map(int,input().split())
beat = min(b,k)
b -= beat
k -= beat
aeat = min(a,k)
a -= aeat
print(a,b)

Failing test case input:
22565061889 581054487 0010010110001

Expected output:
12554951888 581054487


Actual output:
13136006375 0


Fixed submission (verdict: Accepted):
a,b,k = map(int,input().split())
aeat = min(a,k)
a -= aeat
k -= aeat
beat = min(b,k)
b -= beat
print(a,b)

Problem: p02818
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, k = map(int, input().split())

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


Failing test case input:
24844196728 933260677 1010110100001

Expected output:
0 0


Actual output:
0 -984332642596


Fixed submission (verdict: Accepted):
a, b, k = map(int, input().split())

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