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

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

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

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

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

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):

if __name__ == "__main__":
    A, B, K = input().split()
    A = int(A)
    B = int(B)
    K = int(K)
    A = A - K
    if A < 0:
        B = B + A
        A = 0
    if B < 0:
        B = 0
    print(str(A) + " " + str(B))

Solution (Python):
def main():
    A,B,K = map(int,input().split())
    if A+B < K:
        print(0,0)
    else:
        if A < K:
            print(0, A+B-K)
        else:
            print(A-K, B)
 
if __name__ == '__main__':
    main()

Solution (Python):
At,Ba,K = (int(x) for x in input().split())

if K <= At:
    print(At - K)
    print(Ba)
elif K <= At + Ba:
    print(0)
    print(Ba - (K - At))
else :
    print(0)
    print(0)

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

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

if aoki + takahashi <= K:
  print(0, 0)
elif takahashi < K and K <= takahashi+aoki:
  print(0, aoki+takahashi-K)
else:
  print(takahashi-K, aoki)

Solution (Python):
a,b,k = (int(x) for x in input().split())

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

print(a1,b1)

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


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

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):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

def main():
    a,b,k=MI()
    taka=max(a-k,0)
    if taka:aoki=b
    else:aoki=max(0,b-(k-a))
    print(taka,aoki)
main()

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):
def solve(a,b,k):
    if a==0 and b==0:
        return '0 0'
    if a>=k:
        str = '%d %d' % (a-k,b)
        return str
    else:
        b = b + a - k
        a = 0
        if b<0:
            return '0 0'
        str = '0 %d' % (b)
        return str 
        

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

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(' '))

if A == B and A < K and B < K:
    print('0 0')
else:
    if A - K < 0:
        tr = 0
        ar = B - (K - A)
        if ar < 0:
            print('{} {}'.format(tr, 0))
        else:
            print('{} {}'.format(tr ,ar))
    else:
        tr = A - K
        ar = B
        print('{} {}'.format(tr, ar))

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

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

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

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

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

Solution (Python):

a, b, k = map(int, input().split())
ra = max(0, a-k)
rb = max(b - k + a, 0) if a < k else b

print(ra, rb)

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

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

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

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

Solution (Python):
A, B, K = input().split()
C = int(K)-int(A)
D = int(K)-int(B)

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

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

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

Solution (Python):
a,b,k= [int(i) for i in input().split()]
if k == a:
    print(0,b)
elif k < a:
    print(a-k,b)
elif k > a:
    print(0, max(b-(k-a),0))

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

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

print(str(resa) + " " + str(resb))

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):
import sys

A, B, K = [int(num) for num in input().split()]

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

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

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

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

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

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("{} {}".format(a, b))
"""

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

print("{} {}".format(ax, bx))

Solution (Python):
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7


a, b, k = list(map(int, sys.stdin.buffer.readline().split()))

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

Solution (Python):
line = input().split(' ')
A = int(line[0])
B = int(line[1])
K = int(line[2])

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

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


if __name__ == '__main__':
    main()

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

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

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

print(a, b)

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)

def main():
    a,b,k = LI()
    b = max(0,b-max(0,(k-a)))
    a = max(0,a-k)

    return JA([a,b]," ")


print(main())

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

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())

a = 0
b = 0

if A-K >=0:
    a = A-K
    b = B
elif B - (K-A) >=0:
    b = B - (K-A)

print(a,b)

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

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

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

Solution (Python):

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()

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

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

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

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

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

print(a, b)

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

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


print(x,y)

Solution (Python):
input_list = list(map(int, input().split()))
takahashi = input_list[0]
aoki = input_list[1]
turn = input_list[2]
if takahashi >= turn:
    takahashi -= turn
else:
    turn -= takahashi
    takahashi = 0
    if turn > aoki:
        aoki = 0
    else:
        aoki -= turn
print(takahashi, aoki)

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

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):


import sys


def s2nn(s): return [int(c) for c in s.split(' ')]


def ss2nn(ss): return [int(s) for s in list(ss)]


def ss2nnn(ss): return [s2nn(s) for s in list(ss)]


def i2s(): return sys.stdin.readline().rstrip()


def i2n(): return int(i2s())


def i2nn(): return s2nn(i2s())


def ii2ss(n): return [i2s() for _ in range(n)]


def ii2nn(n): return ss2nn(ii2ss(n))


def ii2nnn(n): return ss2nnn(ii2ss(n))


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


main()

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):
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):
import sys

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

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


main()

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

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

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

Solution (Python):
import sys

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

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

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

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

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

Solution (Python):
import numpy as np
data = input()
a = np.int64(data.split(' ')[0])
b = np.int64(data.split(' ')[1])
k = np.int64(data.split(' ')[2])

a1 = np.max([0,a-k])
b1 = np.max([b - max((k-a),0),0])

print(str(a1) + ' ' + str(b1))

Solution (Python):
def main():
	a,b,k = map(int,input().split())
	
	
	
	
	
 
	if k-a >= 0:
		takahashi = 0
		nokori = k-a
		aoki = b - (k-a)
	else:
		takahashi = a-k
		aoki = b
 
	if aoki < 0:
		aoki = 0
	l = []
	l.append(takahashi)
	l.append(aoki)
	
	print(' '.join(map(str, l)))
 
	
 
 
if __name__ == '__main__':
	main()

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())
ansa=max(a-k,0)
if a<=k:
  print(ansa,max(b-(k-a),0))
else:
  print(ansa,b)

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

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

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 = input().split()
a = int(a)
b = int(b)
k = int(k)

if k >= a:
    k -= a
    a = 0
    if k >= b:
        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):
import numpy as np

DEBUG = False

def dprint(*args):
    if DEBUG:
        print(*args)

digit = 6

def to_str(x):
    if x[0] == 0:
        return str(x[1])
    else:
        return "{:d}{:06d}".format(x[0], x[1])


def add(x, y):
    carry = 0
    new1 = x[1] + y[1]
    if new1 >= 1000000:
        carry = 1
        new1 -= 1000000
    new0 = x[0] + y[0] + carry
    return [new0, new1]

def sub(x, y):
    carry = 0
    new1 = x[1] - y[1]
    if new1 < 0:
        carry = 1
        new1 += 1000000
    new0 = x[0] - y[0] - carry
    return [new0, new1]

def gt(x, y):
    if x[0] > y[0]:
        return True
    elif x[0] < y[0]:
        return False
    else:
        if x[1] > y[1]:
            return True
        else:
            return False

abk = input().split(' ')
a_s, b_s, k_s = abk

nums = []
for t_str in abk:
    if len(t_str) > 6:
        upper, lower = int(t_str[0:-6]), int(t_str[-6:])
    else:
        upper, lower = 0, int(t_str)
    nums.append([upper, lower])

a, b, k = nums
dprint(a_s, b_s, k_s)
dprint(a, b, k)
dprint(gt(a, b))
dprint(gt(b, a))
dprint(gt(a, k))
dprint(gt(k, a))

if(gt(a, k)):
    result = sub(a, k)
    print(to_str(result), b_s)
else:
    mod = sub(k, a)
    if(gt(b, mod)):
        mod2 = sub(b, mod)
        print(0, to_str(mod2))
    else:
        print(0, 0)

Solution (Python):
li = list(map(int,input().split()))
a=li[0]
b=li[1]
k=li[2]
if a<k:
    if b<k-a:
        a=0
        b=0
    else:
        b=b-k+a
        a=0
        
else:
    a=a-k

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

Solution (Python):
import sys

A, B, C = raw_input().split()
A = int(A)
B = int(B)
C = int(C)

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

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

print(ansa, ansb)

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):
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
else:
    b=0

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

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):
def f(A,B,K):
    a=A-min(A,K)
    b=B-(K-min(A,K))
    if b<0: 
        b=0
    return a,b
A,B,K= map(int,input().split())
a=f(A,B,K)
print(a[0],a[1])

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

Solution (Python):
def answer(A,B,K):
	takahashi = A
	aoki = B

	takahashi = A - K
	if takahashi >= 0:
		return [takahashi,aoki]
	elif takahashi < 0:
		takahashi = 0
		aoki = aoki - abs(A - K)
		aoki = 0 if aoki < 0 else aoki
		return [takahashi, aoki]
	else:
		return [takahashi, aoki]

A,B,K = map(int, input().split())
takahashi, aoki = answer(A,B,K)
print("{} {}".format(takahashi, aoki))

Solution (Python):
a,b,k = (int(i) for i in input().split())

ak = k-a

if 0 < ak :
  
  bk = b - ak 
  
  if 0 < bk :
    
    print(0,bk)
    
  elif bk < 0 :
    
    print(0,0)
  
  elif bk == 0 :
    
    print(0,0)
  
  
elif ak < 0 :
  
  print(a-k,b)
  
elif ak == 0 :
  
  print(0,b)

Solution (Python):
a,b,c = [int(i) for i in input().split()]
while True:
    if c <= a:
        a -= c
        print(a, b)
        break
    else:

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

Solution (Python):
a, b, k = [int(x) for x in input().split()]
if a<=k:
    k -= a
    a = 0
    if b<=k:
        k -= b
        b = 0
    elif b>k:
        b -= k
        k = 0
else:
    a -= k
    k = 0
print(str(a)+" "+str(b))

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

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

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

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

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

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

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())
if a < k:
    print(0, max(0, b - k + a))
else:
    print(a - k, b)

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

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

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

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



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

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

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



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

Solution (Python):
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    a, b, k = list(map(int, readline().split()))
    am = min(a, k)
    a -= am
    k -= am
    bm = min(b, k)
    b -= bm
    print(a, b)


if __name__ == '__main__':
    solve()

Solution (Python):
a,b,k=map(int,input().split())
k2=0
a2=0
if a>=k:
    k2=a-k
    a=a-k
    print("{0} {1}".format(a,b))
    exit()
else:
    k2=k-a
    a=0
if b>=k2:
    b=b-k2
else:
    b=0
print("{0} {1}".format(a,b))

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

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

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

Solution (Python):

import sys
 
 
def main():
    list1  = list(map(int, input().split(' '))) 
    a, b, k = list1
  
    if a > k:
        a = a - k
      
    elif a + b >= k:
        b = b - (k - a)
        a = 0
        
    else:
        a = 0
        b = 0
        
    print(a, b)
    
    
  
    return 0
 
 
if __name__ == '__main__':
    main()

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

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

Solution (Python):
import numpy as np

x = list(map(int, input().split()))

if x[2] >= x[0] and x[0] >= 1:
    x[2] -= x[0]
    x[0] = 0

    if x[2] >= x[1] and x[1] >= 1:
        x[1] = 0
    else:
        x[1] -= x[2]

elif x[2] < x[0] and x[0] >= 1:
    x[0] -= x[2]

elif x[0] == 0 and x[1] == 0:
    pass
elif x[0] == 0 and x[1] >= 1:
    if x[2] >= x[1] and x[1] >= 1:
        x[1] = 0
    else:
        x[1] -= x[2]



print(str(x[0]) + " " + str(x[1]))

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
else:
    k-=a
    a=0
    if k<=b:
        b-=k
    else:
        b=0
print(*[a,b],sep=' ')

Solution (Python):
a, b, k = list(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 = list(map(int, input().split()))
 
if(A+B>=K and A<=K):
  print(0, end=" ")
  print(B-K+A)
elif(A+B>=K):
  print(A-K, end=" ")
  print(B)
else:
  print(0, end=" ")
  print(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())
if k<=a:
    print(a-k,b)
else:
    print(0,max(0,b-(k-a)))

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

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

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

Solution (Python):

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)

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

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

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

Solution (Python):
if __name__ == '__main__':
    a,b, c = map(int, input().split())
    if c >= a:
        c = c -a
        a = 0
        if c >= b:
            b = 0
        else:
            b = b- c
    else:
        a = a -c
    print( str(a)+ " "+ str(b) )

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

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

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

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

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

A-=X
K-=X
B-=K

print(A,max(0,B))

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

if T >= 0:
    print(T, O)
elif O+T >=0:
    print(0,O+T)
else:
    print(0,0)

Solution (Python):

import sys
read = sys.stdin.readline


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_matrix(H):
    '''
    H is number of rows
    '''
    return [list(map(int, read().split())) for _ in range(H)]


def read_map(H):
    '''
    H is number of rows
    文字列で与えられた盤面を読み取る用
    '''
    return [read()[:-1] for _ in range(H)]


def read_col(H, n_cols):
    '''
    H is number of rows
    n_cols is number of cols

    A列、B列が与えられるようなとき
    '''
    ret = [[] for _ in range(n_cols)]
    for _ in range(H):
        tmp = list(map(int, read().split()))
        for col in range(n_cols):
            ret[col].append(tmp[col])

    return ret


A, B, K = read_ints()
ans1 = max(A - K, 0)
left_p = max(K - A, 0)
ans2 = max(B - left_p, 0)
print(ans1, ans2)

Solution (Python):
temp = list(map(int,input().split()))
a = temp[0]
b = temp[1]
k = temp[2]
if k > 0:
  if k < a:
    a = a - k
  else:
    k = k - a
    a = 0
    if k < b:
      b = b - k
    else:
      b = 0

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

Solution (Python):
A, B, K = map(int, raw_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 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+B < K:
    print(0,0)
else:
    if A < K:
        print(0, A+B-K)
    else:
        print(A-K, B)

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

eat = min(A, K)
A -= eat
K -= eat
eat = min(B, K)
B -= eat
print(A, 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
print('{} {}'.format(A, B))

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

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

print(A,B)

Solution (Python):
a, b, k = [int(x) for x in 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())
if a>=k:
  print(a-k,b)
elif a+b>=k:
  print(0,b+a-k)
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):
number = input()
a,b,k = [int(ele)for ele in number.split(' ')]
res = a - k
if res < 0:
    a = 0
    b = b + res
    b = 0 if b < 0 else b
else:
    a = res
print(a,b)

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

elif a <= k:
    TAKA = 0
    AOKI = b-(k-a)
    print(TAKA, AOKI)
else:
    TAKA = a-k
    AOKI = b
    print(TAKA, AOKI)

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

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):
import sys
def input():
    return sys.stdin.readline()[:-1]

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

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

print(A,B)

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