Problem:
 Score : 200 points    Problem Statement Takahashi has A cookies, and Aoki has B cookies.
Takahashi will do the following action K times:   If Takahashi has one or more cookies, eat one of his cookies.  Otherwise, if Aoki has one or more cookies, eat one of Aoki's cookies.  If they both have no cookies, do nothing.   In the end, how many cookies will Takahashi and Aoki have, respectively?      Constraints  0 \leq A \leq 10^{12}  0 \leq B \leq 10^{12}  0 \leq K \leq 10^{12}  All values in input are integers.         Input Input is given from Standard Input in the following format:  A  B  K       Output Print the numbers of Takahashi's and Aoki's cookies after K actions.        Sample Input 1 2 3 3      Sample Output 1 0 2  Takahashi will do the following:   He has two cookies, so he eats one of them.  Now he has one cookie left, and he eats it.  Now he has no cookies left, but Aoki has three, so Takahashi eats one of them.   Thus, in the end, Takahashi will have 0 cookies, and Aoki will have 2 .       Sample Input 2 500000000000 500000000000 1000000000000      Sample Output 2 0 0  Watch out for overflows.

Solution (Python):
T, A, K = map(int,input().split())

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

Solution (Python):
def main():
    A, B, K = map(int, input().split())
    a = max(A-K, 0)
    b = B - max(min(K-A, B), 0)
    print(a, b)


if __name__ == "__main__":
    main()

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

Solution (Python):

a,b,k = map(int,input().split())
"""
for i in range(k):
    if a >= 1:
        a -= 1
    elif b >= 1:
        b -= 1
print(a,b)
"""

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

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

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

Solution (Python):
A, B, K = map(int, input().split())
count = 0

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

Solution (Python):
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(str(0),str(0))

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

Solution (Python):
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(str(0) + " " + str(0))

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

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

Solution (Python):
a,b,k=map(int,input().split())
li=[0,0]
li[0]=max(a-k,0)
li[1]=max(min(b-(k-a),b),0)
print(*li)

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

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

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

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

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

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

Solution (Python):
a,b,k=[int(i) for i in input().split()]
if a<=k:
    k-=a
    a=0
else:
    a-=k
    k=0
if b<=k:
    k-=b
    b=0
else:
    b-=k
print('%d %d'%(a,b))

Solution (Python):
from collections import Counter,defaultdict,deque
import sys
import bisect
import math
import itertools
import string
import queue
import copy
from itertools import permutations, combinations
from heapq import heappop, heappush

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(map(int, input().split())) for _ in range(n)]


def main():
    a,b,k = inpm()
    a,k = a-k,k-a
    if a < 0:
        a = 0
    if k > 0:
        b -= k
    if b < 0:
        b = 0
    print(a,b)
    
if __name__ == "__main__":
    main()

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

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

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

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



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

Solution (Python):
a,b,k=map(int,input().split())
if a>=k:
  aans=a-k;
  bans=b
  
else:
  aans=0;
  bans=max(0,b-(k-a))

print(aans,bans)

Solution (Python):
from sys import stdin

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

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

Solution (Python):
a,b,k=map(int, input().split())
if a-k>=0:
    print(a-k, b)
elif a-k<0:
    print(0, max(0,b+(a-k)))

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

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

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

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

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

print(A,B)

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

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

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

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

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

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

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

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

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

Solution (Python):
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 = 0
	b = 0
		
print(a, b)

Solution (Python):
def getdata_input():
    while True:
        yield input()
def callFunc2(it):
    A0,B0,K=map(int, next(it).split())
    A=[0]
    B=[0]
    
    t=min(K,A0)
    A.append(t)
    t=min(K-t,B0)
    B.append(min(t,B0))
    return(" ".join([str(A0-sum(A)), str(B0-sum(B))]))
  
it=getdata_input()
print(callFunc2(it))

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

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

if A >= K:
    t = A - K
    a = B
else:
    t = 0
    res = K - A
    if res < B:
        a = B - res
    else:
        a = 0

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

Solution (Python):
a,b,k = map(int,input().split())
if k > a:
  k-=a
  a=0
  if k > b:
    b=0
  else:
    b-=k
else:
  a-=k
print(' '.join([str(a),str(b)]))

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

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


print(str(a)+' '+str(b))

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

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

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

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

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

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

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

Solution (Python):
lst = list(map(int,input().split()))
a = lst[0]-lst[2]
ans1 = max(a, 0)
b = lst[1] + min(0, a)
ans2 = max(b, 0)
print(str(ans1) + " " + str(ans2))

Solution (Python):
A,B,K=(int(x) for x in input().split())

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

Solution (Python):



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

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

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

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

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

Solution (Python):
a,b,k=[int(i) for i in input().split()]
if a>=k:
    print("{} {}".format(a-k,b))
elif a+b>=k:
    print("0 {}".format(b-k+a))
else:
    print("0 0")

Solution (Python):
a,b,k=map(int,input().split())
atmp=max(0,a-k)
ktmp=max(k-a,0)
btmp=max(0,b-ktmp)
print(atmp,btmp)

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

Solution (Python):


A, B, K = [int(x) for x in input().split()]
AB = A + B
if A > K:
    print(A - K, B)
elif AB > K:
    print(0, AB - K)
else:
    print(0, 0)

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

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

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

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

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

Solution (Python):
A,B,K = map(int, input().split())
sum = A + B

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

Solution (Python):
a, b, k = map(int, input().split())
 
if a > k:
  print('{} {}'.format(a - k, b))
elif a + b > k:
  print('0 {}'.format(a + b - k))
else:
  print('0 0')

Solution (Python):
A,B,K = (int(x) for x in input().split() )

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

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

A = []
if a < c:
    A.append(0)
    c = c-a
    if b<c:
        A.append(0)
    else:
        A.append(b-c)
else:
    A.append(a-c)
    A.append(b)

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

Solution (Python):
import sys
sys.setrecursionlimit(1000000000)
from fractions import gcd
from itertools import count
from functools import lru_cache
from collections import defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok


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


main()

Solution (Python):
import sys
a, b, k = [int(i) for i in sys.stdin.readline().split()]
print(max(0, a - k), max(0, min(b, a+b-k)))

Solution (Python):
takahashi, aoki, k = map(int, input().split(" "))


if k >= takahashi:
    k -= takahashi
    takahashi = 0
    if k >= aoki:
        k -= aoki
        aoki = 0
    else:
        aoki -= k 
else:
    takahashi -= k
        
print(takahashi, aoki)

Solution (Python):
A,B,K=map(int,input().split())
a=max(0,A-K)
b=min(A+B-K,B)
if b<0:
  b=0
print(*[a,b])

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

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

Solution (Python):
a,b,k = map(int,input().split())
a = a-k
if a <= 0:
  b = b+a
  if b<=0:
    print('{} {}'.format(0,0))
  else:
    print('{} {}'.format(0,b))
else:
  
  print('{} {}'.format(a,b))

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

Solution (Python):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

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

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

Solution (Python):


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

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

print(A, B)

Solution (Python):
a, b, k = map(int, input().split())
x = min(a, k)
a -= x
k -= x
y = min(b, k)
b -= y
k -= y
print(a, b)

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

A -= K

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

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

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

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

Solution (Python):
import sys
import math
from collections import defaultdict

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def II(): return map(int, input().split())
def III(): return list(map(int, input().split()))
def Line(N,num):
    if N<=0:
        return [[]]*num
    elif num==1:
        return [I() for _ in range(N)]
    else:
        read_all = [tuple(II()) for _ in range(N)]
        return map(list, zip(*read_all))



A,B,K = II()

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

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

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

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

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

print(ans1,ans2)

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

Solution (Python):
a, b, k = list(map(int, input().split()))
if 0 <= a <= k:
    a, k = 0, k - a
    if 0 <= b <= k:
        b = 0
    else:
        b -= k
else:
    a -= k
print(a, b)

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

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

Solution (Python):
a, b, k = list(map(int, input().split()))
ka = k - a
if ka <= 0:
    print('%d %d' % (a - k, b))
else:
    if b < ka:
        ka = b
    print('0 %d' % (b - ka))

Solution (Python):
import sys
sys.setrecursionlimit(10000000)







INF = 500000
MOD = 10**9+7

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

Solution (Python):
A,B,K = map(int,input().split())
if A >=K :
  print(*[A-K,B])
elif A < K and B >= (K-A):
  print(*[0,B-(K-A)])
else:
  print(0,0)

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

Solution (Python):
def A():
    temp = input().split()
    print(''.join(temp[::-1]))

def B():
    temp = [int(n) for n in input().split()]
    A = temp[0]
    B = temp[1]
    K = temp[2]
    to_minus = min(A, K)
    A -= to_minus
    K -= to_minus
    if K > 0:
        B -= min(B, K)
    print (A, B)

B()

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

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

Solution (Python):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

if A==0 and B==0:
  pass
elif A>0:
  if A>=K:
  	A = A-K
  elif A+B>K:
    B = B-K+A
    A = 0
  else:
    A=0
    B=0
elif B>K:
  B=B-K
else:
  B=0
print('%d %d' % (A,B))

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

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

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

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

Solution (Python):
a,b,k= map(int,input().split())
ans1=a-k
if ans1<0:
    ans2=b-(k-a)
    ans1=ans1-ans1
else:
    ans2=b
if ans2<0:
    ans2=0
print("{} {}".format(ans1,ans2))

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

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

print(A_, B_)

Solution (Python):

input_line = input()
abk = input_line.split(" ") 
ABK = [int(n) for n in abk]



if ABK[0] + ABK[1] <= ABK[2]:
    A = 0
    B = 0

elif ABK[0] <= ABK[2] and ABK[1] > ABK[2] - ABK[0]:
    A = 0
    B = ABK[1] -  (ABK[2] - ABK[0])

elif ABK[0] > ABK[2]:
    A = ABK[0] - ABK[2]
    B = ABK[1]

    
print(A," ",B)

Solution (Python):
A,B,K = map(int,(input().split()))
rem = A - K
if(A+B < K):
    print('0 0')
elif(rem < 0):
    print('0' + ' ' + str(B+rem))
else:
    print(str(rem) + ' ' + str(B))

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

Solution (Python):
a, b, k = map(int, input().split())
if k <= a:
    ans = a - k, b
elif a < k < a + b:
    ans = 0, b - (k - a)
else:
    ans = 0, 0

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

Solution (Python):
x,y,z = input().split()
a = int(x)
b = int(y)
c = int(z)
if a > c:
  print(a-c,b)
elif a <= c < a+b:
  print(0,a+b-c)
elif a+b <= c:
  print(0,0)

Solution (Python):
cookies = [int(x) for x in input().split()]
leftOver = cookies[0] - cookies[2]
takahashi = max(0, leftOver)
print(str(takahashi)+ ' ' + (str(cookies[1]) if takahashi > 0  else str(max(0,cookies[1] - abs(leftOver)))))

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


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

Solution (Python):
A,B,K=[int(s) for s in input().split()]
if K>=A+B:
  ls=[0,0]
elif K>=A:
  ls=[0,B+A-K]
else:
  ls=[A-K,B]
print(*ls)

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

Solution (Python):


from collections import deque, defaultdict
import itertools as ite
import sys
import math
import decimal

sys.setrecursionlimit(1000000)

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

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

Solution (Python):
def solve():
	a, b, k = map(int, input().split())
	if k <= a:
		print(max(0, a - k), b)
	elif k <= a + b:
		print(0, max(0, b - (k - a)))
	else:
		print(0, 0)
solve()

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

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

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

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

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

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

Solution (Python):
a = list(map(int,input().split()))
A = a[0]
B = a[1]
K = a[2]
A1 = A - K
B1 = B
if A1 < 0:
    B1 = A1 + B
    A1 = 0
    if B1 < 0:
        B1 = 0

print(A1,end=" ")
print(B1)

Solution (Python):
A, B, K = map(int, input().split())
T = min(A, K)
A -= T
K -= T
T = min(B, K)
B -= T
print(A, B)

Solution (Python):
A, B, K = [int(i) for i in input().split()]
t = min(A, K)
A -= t
K -= t
t = min(B, K)
B -= t
print(A, B)

Solution (Python):
A,B,K = map(int,(input().split()))
rem = A - K
if(A+B < K):
    print('0 0')
elif(rem < 0):
    print('0' + ' ' + str(B+rem))
else:
    print(str(rem) + ' ' + str(B))

Solution (Python):
def judge(a,b,k):
	
	if k <= a: return a-k, b
	
	rest_k = k-a
	if rest_k <= b: return 0, b-rest_k
	return 0,0

a,b,k = [int(e) for e in input().split(" ")]
a,b = judge(a,b,k)
print(a,b)

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

Solution (Python):
import os
import sys

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

        if KK >= B :
            B = 0
        else :
            B = B - KK
    else :
        A = A - K
    print (str(A) + " " + str(B))

if __name__ == '__main__':
    main()

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

while k != 0:
    if a > 0:
        t = min(a, k)
        a -= t
        k -= t
    elif b > 0 and k > 0:
        t = min(b, k)
        b -= t
        k -= t
    if a == 0 and b == 0:
        break

print(a, b)

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

Solution (Python):
import sys
input = sys.stdin.readline
A,B,K=map(int,input().rstrip().split())
 
"""
def resolve():
    if(A>K):
        ansA=int(A)-int(K)
        ansB=int(B)
    else:
        ansA=0
        ansB=int(B)-(int(K)-int(A))
        if(ansB<0):
            ansB=0
    print(str(int(ansA))+" "+str(int(ansB)))
"""

def resolve():
    if(A>K):
        ansA=int(A)-int(K)
        ansB=int(B)
    else:
        ansA=0
        ansB=int(B)-(int(K)-int(A))
        if(ansB<0):
            ansB=0
    print(ansA,ansB)


import sys
from io import StringIO
import unittest

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """2 3 3"""
        output = """0 2"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """500000000000 500000000000 1000000000000"""
        output = """0 0"""
        self.assertIO(input, output)
 
if __name__ == "__main__":
    
    resolve()

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

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

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

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

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

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

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

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

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

Solution (Python):
a,b,k=map(int,input().split())
d=a+b
if(k>=d):
    print("0 0")
elif(d>k and a<k):
    print("0 ",d-k)
elif(d>k and a>=k):
    print(a-k,b)
elif(a<k and d>=k):
    print("0 ",d-k)

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

A=a

B=b
K=k

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

Solution (Python):
a,b,k = map(int,input().split())
if a>=k:
    a = a-k
    k = 0
    print(a,b)
elif a<k:
    k =k-a
    a =0
    print(0,max(0,b-k))

Solution (Python):

a,b,k=list(map(int,input().split()))
ans=[]
if k<=a:
    ans.append(a-k)
    ans.append(b)
elif (k-a)<=b:
    ans.append(0)
    ans.append(b-k+a)
else:
    ans.append(0)
    ans.append(0)
x=str(ans[0])+' '+str(ans[1])
print(x)

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

Solution (Python):
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 = 0
  b = 0
print(str(a)+" "+str(b))

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

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

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

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

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

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

Solution (Python):
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)
else:
  print(0,0)

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

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

Solution (Python):
a, b, k = map(int, input().split())
if a+b < k:
  print('0 0')
elif a < k:
  print('{} {}'.format(0, a+b-k))
else:
  print('{} {}'.format(a-k, b))

Solution (Python):


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

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

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

Solution (Python):
from sys import stdin as st


def main():
    l = [int(e) for e in st.readline().split()]
    if l[0] <= l[2]:
        l[2] -= l[0]
        l[0] = 0
        if l[1]<=l[2]:
            print('0 0')
        else:
            l[1] -= l[2]
            l[2] = 0
            print('%d %d' % (l[0], l[1]))
    else:
        l[0] -= l[2]
        l[2] = 0
        print('%d %d' % (l[0], l[1]))


main()

Solution (Python):


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

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

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

Solution (Python):
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])

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

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

acc = min(a, k)
a -= acc
k -= acc

acc = min(b, k)
b -= acc

print(a, b)

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

if c<a:
    print(a-c,b)
else:
    print(0,max(b+a-c,0))

Solution (Python):
a,b,k=map(int,input().split())
if a<=k:
  if b<=k-a:
    b=0
  else:
    b=b-k+a
  a=0
else:
  a=a-k
print(str(a)+" "+str(b))

Solution (Python):


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)

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


main()

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