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

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

Solution (Python):


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

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

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

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

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

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

Solution (Python):
def main():
    A, B, K= [int(x) for x in input().split()]
    A -= K
    left = A
    if left < 0:
        A = 0
    else:
        print(A, B)
        return

    B += left
    if B < 0:
        B = 0

    print(A, B)

if __name__ == "__main__":
    main()

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

if(b < 0):
    b = 0

print(a,b)

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

Solution (Python):
import math
import bisect
import collections
import itertools
def gcd(a,b):return math.gcd 
def lcm(a,b):return (a*b) // math.gcd(a,b) 
def iin(): return int(input()) 
def imn(): return map(int, input().split()) 
def iln(): return list(map(int, input().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def comb(l, n): return itertools.combinations(l, n) 
def divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    return divisors

A,B,K = imn()

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


print(str(A) + ' ' + str(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):
a,b,k = map(int,input().split())

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

if a+b > k:
    print(0, b-k+a)
    exit()
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):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
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 [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  a,b,k=LI()

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

main()

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

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

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

if a >= k:
    print("{} {}".format(a-k, b))
elif a+b >= k:
    print("{} {}".format(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:
  print(0, max(0, b - (k - a)))

Solution (Python):
def examA():
    S, T = LSI()
    ans = T+S
    print(ans)
    return

def examB():
    A, B, K = LI()
    if A>K:
        A -=K
        print(A,B)
        return
    if A+B>K:
        B -=(K-A)
        A = 0
        print(A,B)
        return
    A = 0; B = 0
    print(A,B)
    return

def examC():
    return

def examD():
    return

def examE():
    return

import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,inf
mod = 10**9 + 7
inf = float('inf')

if __name__ == '__main__':
    examB()

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

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

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

Solution (Python):
def solve(a, b, k):
    if a >= k:
        res_a = a - k
        res_b = b
    elif a + b >= k:
        res_a = 0
        res_b = a + b - k
    else:
        res_a = 0
        res_b = 0
    return "{} {}".format(res_a, res_b)


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


def test():
    assert solve(2, 3, 3) == "0 2"
    assert solve(500000000000, 500000000000, 1000000000000) == "0 0"


if __name__ == "__main__":
    test()
    main()

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

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

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

Solution (Python):



def solve(a, b, k):
    d1 = min(a, k)
    a -= d1
    k -= d1
    d2 = min(b, k)
    b -= d2
    k -= d2
    return a, b


def main():
    a, b, k = (int(z) for z in input().split())
    res = solve(a, b, k)
    print(*res)


if __name__ == "__main__":
    main()

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

Solution (Python):

import sys
input = sys.stdin.readline

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

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

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

K_A = A - K

if K_A < 0:
    print(0, max(0, B + K_A))
else:
    print(K_A, B)

Solution (Python):
A, B, K = [int(x) for x in input().split()]
print(max(A-K, 0), end=' ')
print(max(B-(K-A), 0) if A<K else B)

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

A, B, K = MAP()

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

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

if k <= a:
    ans = str(a-k) + ' ' + str(b)
else:
    ans = str(0) + ' ' + str(max(b-(k-a), 0))

print(ans)

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

if abk[2]<=abk[0]:
    print(abk[0]-abk[2],abk[1])
elif abk[2]<=abk[0]+abk[1]:
    print(0,abk[0]+abk[1]-abk[2])
else:
    print(0,0)

Solution (Python):
def two_int():
    N, K = map(int, input().split())
    return N,K

def one_int():
    return int(input())

def one_str():
    return input()

def many_int():
    return list(map(int, input().split()))

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

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


print(str(A)+" "+str(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):




import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline









a,b,k = [int(i) for i in readline().split()]


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


print(*[a,b])

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
import math
from collections import deque
MAX_INT = int(10e15)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

A, B, K = IL()

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

Solution (Python):
inputs = input().split(" ")
a = int(inputs[0])
b = int(inputs[1])
k = int(inputs[2])

tmp = min(a, k)
a -= tmp
k -= tmp
b -= min(b, k)

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

Solution (Python):
from sys import stdin
import numpy as np




def main():
    a, b, k = [int(x) for x in input().split()]
    if a >= k:
        print(a-k, b)
    elif a + b >= k:
        print(0, a + b - k)
    else:
        print(0,0)
    return


if __name__ == "__main__":
    main()

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

d = min(A, K)
A -= d

K -= d
d = min(B, K)
B -= d

print(A, B)

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

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

Solution (Python):
A,B,K = [int(i) for i 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-(k-a))
else:
    print(0,0)

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

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

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

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
mod2 = 998244353
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))

a,b,k = inpl()
c = d = 0
if a <= k:
    c = 0
    tmp = k-a
    d = max(b-tmp,0)
else:
    c = a-k
    d = b
print(c,d)

Solution (Python):
def main():

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

    if K < A:
        return A-K, B
    else:
        return 0, max(0, B-(K-A))
if __name__ == '__main__':
    ans = main()
    print(" ".join(map(str, ans)))

Solution (Python):
import sys
from math import factorial
from fractions import Fraction
import heapq, bisect, fractions
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
MOD = 10**9 + 7

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

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

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

    else:
        print("0 0")

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

eat = min(a, k)
a -= eat
k -= eat
eat = min(b, k)
b -= eat
k -= eat
print(a, b)

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

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

if K<=A:
    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 k > a:
    k = k - a
    a = 0
    b = b - k
    if b < 0:
        b = 0
else:
    a = a - k
print(str(a) + " " + str(b))

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

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

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

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

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

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

Solution (Python):


def main():
    A, B, K = map( int, input().split())
    if A >= K:
        print(A-K, B)
        return
    K -= A
    if B >= K:
        print(0, B-K)
        return
    print(0, 0)
if __name__ == '__main__':
    main()

Solution (Python):

MOD = 10 ** 9 + 7

import math

import itertools



def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default




def main():
    a,b,k=map(int,input().split())
    taka=a-k
    if taka<0:
        taka=0
    noko=k-a
    if noko<0:
        noko=0
    ao=b-noko
    if ao<0:
        ao=0
    print(taka,ao)











if __name__ == "__main__":
    main()

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

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

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

a = A - min(A, K)
k = K - min(A, K)
b = B - min(B, k)

print(a, b)

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

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

Solution (Python):
import collections
import math
import operator as op
from functools import reduce
import numpy as np
import math
import bisect
import heapq


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a


def lcm(a, b):
    return a * b // gcd(a, b)


def get_inputs(cast_func=None):
    if cast_func is None:
        return input().split()
    else:
        return list(map(cast_func, input().split()))


def get_input(cast_func=None):
    if cast_func is None:
        return input()
    else:
        return cast_func(input())


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


if __name__ == '__main__':
    main()

Solution (Python):

a, b, k = map(int, input().split())
tmp = min(a, k)
a -= tmp
k -= tmp
if a == 0:
    tmp2 = min(b, k)
    b -= tmp2
    k -= tmp2
else:
    pass
print(a, b)

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

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

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

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

Solution (Python):
import sys

input = sys.stdin.readline

ri = lambda: int(input())
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]

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

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

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

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

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq 
from itertools import *
import math
import random
import re
import string

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

x = min(A, K)
A -= x
K -= x

x = min(B, K)
B -= x

print(A, B)

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

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

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

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

print(a, b)

Solution (Python):
import sys

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

def main():
    if a >= k:
        return a - k, b
    elif a + b >= k:
        return 0, a + b - k
    else:
        return 0, 0

if __name__ == '__main__':
    ans = main()
    print(*ans, sep=' ')

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

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

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

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

Solution (Python):
import sys, math
def input():
    return sys.stdin.readline()[:-1]
from itertools import permutations, combinations
from collections import defaultdict

sys.setrecursionlimit(10**7)
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())
print(max(a-k,0), max(0,min(b,a + b - k)))

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

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

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

print(A, B)

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

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

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

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

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

print(A,B)

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

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

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

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

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

print(a, b)

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

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

Solution (Python):
A, B, K = map(int, input().split())
m = min(A, K)
A -= m
K -= m
m = min(B, K)
B -= m
K -= m
print(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):
A,B,K = map(int,input().split())

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

Solution (Python):



def ri():
    return int(input())

def rl():
    return list(input().split())

def rli():
    return list(map(int, input().split()))

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



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())
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, raw_input().split())

k = min(A, K)
K -= k
A -= k
k = min(B, K)
K -= k
B -= k
print A, B

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

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

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

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

Solution (Python):











import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,hypot,log 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    A,B,K=MI()
    A_=max(0,A-K)
    K=K-A
    if K>0:
        B=max(0,B-K)
    print(A_,B)
    
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, c = input().split()
a, b, c = int(a), int(b), int(c)
x = min(a, c)
a -= x
c -= x
y = min(b, c)
b -= y
c -= y
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,a+b-k)
else:
    print(0,0)

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

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False
"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""


a,b,k = m()

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

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))


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

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

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

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

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

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

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

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

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