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())
takahashi=0
if a>= k:
    
    takahashi=a-k
else:
    dif=k-a
    takahashi=0    
    
    b=b-dif
    if b<0:
        b=0
print("{0} {1}".format(takahashi,b))

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

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

Solution (Python):


a,b,K=map(int,input().split())
if a<K and b>K-a:
    print(0,b-(K-a))
elif a<K and b<=K-a:
    print(0,0)
elif a>=K:
    print(a-K,b)

Solution (Python):

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

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

print (a,max(b,0))

Solution (Python):



a, b, k = map(int,input().split())
if a >= k:
    ans = [a-k,b]
elif a+b >=k:
    ans = [0,a+b-k]
else :
    ans = [0,0]
print(str(ans[0])+" "+str(ans[1]))

Solution (Python):
def multi_int_input():
    return map(int, input().split())
  
multi_input = multi_int_input()
takahashi, aoki, K = multi_input
if K > takahashi:
  sum_result = K - takahashi - aoki
  if sum_result > 0:
    print("0 0")
  else:
    print("0 {}".format(-sum_result))
else:
  sum_result = takahashi - K
  print("{0} {1}".format(sum_result, aoki))

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

if K >= A:
        K -= A
        A = 0
        flag = 1

if flag == 1 and K >= B:
        K -= B
        B = 0

if A == 0 and B == 0:
                print('0 0')
                exit(0)
        
if A > 0:
        print(A-K, B)
        exit(0)
        
if B > 0:
        print(A, B-K)

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

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

c = max(0, a-k)
d = max(0, b-max(0, k-a))

print(c,d)

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, b-(k-a))

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

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

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

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

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

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

Solution (Python):
line = input().split(" ")

a = int(line[0])
b = int(line[1])
k = int(line[2])

takahashi = 0
aoki = 0

if k <= a:
  takahashi = a - k
  aoki = b
elif k <= a + b:
  aoki = a + b - k

print(str(takahashi) + " " + str(aoki))

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

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

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

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

print(A, B)

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

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

print(0, A+B-K)

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

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

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

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

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


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
A,B,K = map(int,input().split(" "))
C=K-A
if C >= 0:
    E = 0
elif C < 0:
    E = C * -1  
else:
    E = C
if E > 0:
    F = B
else:
    D=B-C
    if D >= 0:
        F = D
    else:
        F = 0

print('{} {}'.format(E , F))

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

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

print(a, b)

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

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

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

print(A - a, B - b)

Solution (Python):
import unittest


class TestB(unittest.TestCase):
    def test_1(self):
        self.assertEqual(think(2, 3, 3), (0, 2))

    def test_2(self):
        self.assertEqual(think(500000000000, 500000000000, 1000000000000), (0, 0))

    def test_3(self):
        self.assertEqual(think(1, 1, 10), (0, 0))


def solve():
    a, b, k = read()
    result = think(a, b, k)
    write(result)


def read():
    return read_int(3)


def read_int(n):
    return read_type(int, n, sep=' ')


def read_float(n):
    return read_type(float, n, sep=' ')


def read_type(t, n, sep):
    return list(map(lambda x: t(x), read_line().split(sep)))[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(a, b, k):
    if a >= k:
        return a - k, b
    rem = k - a
    if b >= rem:
        return 0, b - rem
    else:
        return 0, 0


def write(result):
    print('{0:d} {1:d}'.format(result[0], result[1]))


if __name__ == '__main__':
    
    solve()

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

Solution (Python):
x = [int(i) for i in input().split()]
ans1 = x[0]
ans2 = x[1]
if ans1 >= x[2]:
    ans1 -= x[2]
else:
    x[2] -= ans1
    ans1 = 0
    ans2 = max(0,ans2 - x[2])
print(ans1,ans2)

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

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

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

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

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

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

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


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):
a2,b2,k2=input().split()
a2=int(a2)
b2=int(b2)
k2=int(k2)
if a2-k2 >0:
    print(a2-k2,b2)
elif a2+b2-k2>0:
    print("0",a2+b2-k2)
else:
    print("0 0")

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

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

last_A = max(A - K, 0)
last_B = max(B - max(K - A, 0), 0)
out = "{} {}".format(last_A, last_B)

print(out)

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

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

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

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

print(a, b)

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

print(a1, a2)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys
from pprint import pprint

def solve(a, b, k):
    delta = a - k
    if delta < 0:
        b = b + delta
    print(max(0, delta), max(0, b))


if __name__ == '__main__':
    a, b, k = map(int, sys.stdin.readline().strip().split(" "))
    solve(a, b, k)

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

Solution (Python):

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


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

    print(t, a)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    K = int(next(tokens))  
    solve(A, B, K)

if __name__ == '__main__':
    main()

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


if __name__ == '__main__':
    solve()

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

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

print(a, b)

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

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

if __name__ == '__main__':
    main()

Solution (Python):
import sys
input = sys.stdin.readline

A, B, K = map(int, input().split())
Ar = max(0, A-K)
K = max(0, K-A)
Br = max(0, B-K)

print(Ar,Br)

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

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

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

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

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())
a_res = 0
b_res = b
if a - k > 0:
    a_res = a - k
else:
    k_temp = k - a
    b_res = b - k_temp
    if b_res < 0:
        b_res = 0
print(str(a_res) + ' ' + str(b_res))

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

main()

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

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

print(A, max(B, 0))

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

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

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

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

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

if __name__ == "__main__":
    main()

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)

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

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

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

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

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

if A >= K :
    A = A - K 
    print(A,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 <= 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())


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

Solution (Python):
a, b, k = list(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 %d"%(a+b-k))
else:
    print("%d %d"%(a-k, b))

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


def solve():
    if ((A - K) > 0):
        return [A - K, B]
    ans = B - (K - A)
    return [0,  max(0, ans)]


print(*solve())

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

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

eatenA = min(a , k)
ans1 = a - eatenA
eatenB = max(k - a, 0)
ans2 = b -  eatenB

if ans2 < 0:
    ans2 = 0

print(ans1, ans2 )

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

ans = [0, 0]

if k > a:
    ans[1] = a + b - k
    if ans[1] < 0:
        ans[1] = 0
else:
    ans[0] = a - k
    ans[1] = b

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

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

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

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

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

Solution (Python):

a, b, k = list(map(int,input().split()))
s = a
t = b
if k >= 0:
    if  a > 0:
        if k > a:
            a = 0
            k = k -s
        else:
            a = a-k
            k = 0
    if b > 0:
        if k >= 0:
            if k > b:
                b = 0
            else:
                b = b-k
print(a,b)

Solution (Python):

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

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

if ans2 < 0:
    ans2 = 0
else:
    pass

print(ans1,ans2)

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

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

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

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

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

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

Solution (Python):
def main():
    a, b, k = [int(i) for i in input().split()]
    after_a = max(a - k, 0)
    k -= (a - after_a)
    b -= k
    b = max(b, 0)
    print(after_a, b)
 
 
if __name__ == '__main__':
    main()

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

a2 = a-k
b2 = b
if a2 < 0:
    b2 = b+a2

if a2 < 1:
    a2 = 0
if b2 < 1:
    b2 = 0
print(a2,b2)

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

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

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

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

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

Solution (Python):

import sys


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


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    K = int(next(tokens))  
    solve(A, B, K)

if __name__ == '__main__':
    main()

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

Solution (Python):
mystr = str(input())
mystrs = mystr.split(' ')
A = int(mystrs[0])
B = int(mystrs[1])
K = int(mystrs[2])
if K <= A:
  ret = "%d %d" % (A - K, B)
else:
  if K - A <= B:
    ret = "0 %d" % (B - (K - A))
  else:
    ret = "0 0"
print(ret)

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

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

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

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

else:
    A = A - K
    K = 0

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

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

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

print(a,b)

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

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

print(a, b)

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

Solution (Python):
s=input().split()
a=int(s[0])
b=int(s[1])
k=int(s[2])
if a>=k:
    print(str(a-k)+" "+str(b))
else:
    if a+b>=k:
        print("0 "+str(b+a-k))
    else:
        print("0 0")

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

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

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

if min(a,k) == a:
    taka = 0
    if min(b, k-a) == b:
        aoki = 0
        print(taka, aoki)
    else:
        aoki = b - (k-a)
        print(taka, aoki)
else:
    taka = a - k
    aoki = b
    print(taka, aoki)

Solution (Python):
import sys
input = sys.stdin.readline
a, b, k = [int(x) for x in input().strip().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 K<=A:
    print("{} {}".format(A-K,B))
else:
    print("{} {}".format(0,max(A+B-K,0)))

Solution (Python):
from collections import defaultdict, deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys
import random
import itertools
import math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt


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


def LF(): return list(map(float, input().split()))


def LI_(): return list(map(lambda x: int(x)-1, input().split()))


def II(): return int(input())


def IF(): return float(input())


def LS(): return list(map(list, input().split()))


def S(): return list(input().rstrip())


def IR(n): return [II() for _ in range(n)]


def LIR(n): return [LI() for _ in range(n)]


def FR(n): return [IF() for _ in range(n)]


def LFR(n): return [LI() for _ in range(n)]


def LIR_(n): return [LI_() for _ in range(n)]


def SR(n): return [S() for _ in range(n)]


def LSR(n): return [LS() for _ in range(n)]


def gcd(x, y):
    if y == 0:
        return x
    return gcd(y, x % y)


def my_index_multi(l, x):
    return [i for i, _x in enumerate(l) if _x == x]


def sosu(x):
    for i in range(2, int(sqrt(x)+1)):
        if x % i == 0:
            return False
    return True


mod = 1000000007
inf = float('INF')


def A():
    S, T= input().split()
    
    
    print(T+S)

    
    return




def B():
    A,B,K= LI()
    temp=A-K
    if temp>=0:
        print(temp,B)
        return
    B=B+temp
    if B<=0:
        print(0,0)
        return
    else:
        print(0,B)
    
    
    

   
    return




def true():
    S = input()
    S = S[:-1]

    tmp = 0
    for x in range(1 << (len(S)-1)):
        func = S[-1]
        for i in range(len(S)-1):
            if(x & (1 << i)):
                tmp += int(func)
                func = S[-2-i]
            else:
                func = S[-2-i]+func
        tmp += int(func)
    print(tmp)

    return


def flagcounter(x):
    if (x == 0):
        return 0
    return flagcounter(x >> 1)+(x & 1)


def C():
    W, H, x, y = LI()

    if (W/2 == x and H/2 == y):
        print(W*H/2, 1)
    else:
        print(W*H/2, 0)

    return





def D():

    N, K = LI()
    A = LI()
    MAX = sum(A)
    if MAX < K:
        print(0)
        return
    Temp = MAX
    ans = 1
    for i in range(N):
        Temp = Temp-A[i]
        if (Temp >= K):
            ans += 1
        else:
            T = Temp+A[i]
            break
    Temp = T
    ckeep = N
    for k in range(N):
        c = N-1
        i -= 1
        Temp = T

        for j in range(N):
            Temp = Temp-A[c]
            if (Temp >= K ):
                ans += 1
            
            elif(c < ckeep and i>=0):
                ans += i
                ckeep = c
                break
            else:
                ckeep = c
                break
            c -= 1
        if i < 0:
            break
        T = T+A[i]
    print(ans)

    return




def E():
    N, K = LI()
    A = LI()
    F = LI()
    A.sort(reverse=True)
    F.sort()
    cost = []
    for i in range(len(N)):
        cost.append(A[i]*F[i])

    a = F[cost.index(max(cost))]

    return




def F():
    N, M = LI()

    value = [0] * M
    power = [0] * M
    for i in range(M):
        a, b = LI()
        value[i] = a
        c = LI()
        L = ['0'] * N
        for k in c:
            L[k - 1] = '1'
        bint = ''.join(L)
        power[i] = int(bint, 2)
    bint = ''.join(list(['1'] * N))
    dp = [inf] * (int(bint, 2)+1)
    t = 0
    cost = 0

    dp[0] = 0
    for s in range(int(bint, 2) + 1):
        for i in range(M):
            t = s | power[i]
            cost = dp[s] + value[i]
            dp[t] = min(dp[t], cost)
    print(-1) if(dp[-1] == inf) else print(dp[-1])

    return

    



def solution(S):
    
    N = len(S)

    pass



if __name__ == '__main__':

    B()

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


print(ansA, end="")
print(" ", end="")
print(ansB)

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

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

Solution (Python):
A,B,K = (int(i) for i in input().split())
if A >= K:
    x = A-K
    y = B
elif B > K-A:
    x = 0
    y = B -(K-A)
else:
    x,y = 0,0

print(x,y)

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

Solution (Python):
coo=list(map(int, input().split()))
tcoo=coo[0]
acoo=coo[1]
k=coo[2]
if k >= tcoo:
    k-=tcoo
    tcoo=0
    if k >= acoo:
        acoo=0
    else:
        acoo-=k
else:
    tcoo-=k
print(str(tcoo)+" "+str(acoo))

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

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

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

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

if b <= k:
    k -= b

print(a, b)

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

print(A, B)

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

t1 = t-c
a1 = a+min(0,(t-c))

print(max(0,t1),max(0,a1))

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

a = A - K

if a >= 0:
    print(a , B)
else:
    if B + a >= 0:
        print(0 , B + a)
    else:
        print(0 , 0)

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

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

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

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

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

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

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

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

print(a, b)