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

a = a -k

if a < 0:
    b = a + b
    a = 0
    if b < 0:
        b = 0

print(a, b)

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

if k >= a+b:
  c = d = 0

elif k == a:
  c = 0

elif k > a:
  c = 0
  d = b - (k - a)

else:
  c = a - k
  
print(c,d)

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

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

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

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

Solution (Python):
c=list(map(int, input().split()))
if c[0]<c[2]:
  if c[1]<c[2]-c[0]:
    print(0,0)
  else:
    print(0,c[1]-(c[2]-c[0]))
else:
  print(c[0]-c[2],c[1])

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

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

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

Solution (Python):



def main():
    
    takahashi, aoki, action_count = map(int, input().split(' '))

    if action_count <= takahashi:
        takahashi = (takahashi - action_count)
    elif takahashi < action_count <= (takahashi + aoki):
        aoki = (takahashi + aoki - action_count)
        takahashi = 0
    elif (takahashi + aoki) < action_count:
        takahashi = 0
        aoki = 0
    
    print(takahashi, aoki)

    return 0
    
    
if __name__ == '__main__':
    main()

Solution (Python):

 
 
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):
ABK=input().split()
A=int(ABK[0])
B=int(ABK[1])
K=int(ABK[2])
if A >= K:
    A=A-K
else:
    K=K-A
    A=0
    if B >= K:
        B=B-K
    else:
        B=0
print(str(A)+' '+str(B))

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

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

x = min(a,k)
a -= x
k -= x
y = min(b,k)
b -= y
print(a,b)

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

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

Solution (Python):
'''input
3 5
1 2 1
2 3 0
'''

from sys import stdin, setrecursionlimit



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

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

print(a, b)

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

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

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

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

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

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

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

a = 0
b = 0

a = max(a, A - K)
K = max(0, K - A)
b = max(b, B - K)

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

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

Solution (Python):
import sys


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


if __name__ == '__main__':
    solve()

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

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

if c[0]>=c[2]:
  c[0]-=c[2]
else :
  c[2]-=c[0]
  c[1]-=c[2]
  c[0]=0
  if c[1]<0:
    c[1]=0
print(c[0],c[1])

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

Solution (Python):
import sys
input = sys.stdin.readline
A,B,K = map(int, input().split())
 
while(K > 0):
  if A >= K:
    A -= K
    K = 0
    break
  else:
    K -= A
    A = 0
    if B >= K:
      B -= K
      K = 0
      break
    else:
      K -= B
      B = 0
      break
print(' '.join(map(str, [A,B])))

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








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

print(str(A), end = " ")
print(str(B))

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

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

Solution (Python):
import sys

def main():

    

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

    ra = max(0, a - k)
    ka = max(0, k - a) 
    rb = b
    if ka > 0:
        rb = max(0, rb - ka)

    print(str(ra) + ' ' + str(rb))

if __name__ == '__main__':
    main()

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

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

print(a, b)

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

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

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

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

print(A, B)

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

Solution (Python):
import string

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

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

Solution (Python):
takahashi,aoki,count = map(int,input().split())
if count >= takahashi:
	aoki = aoki - count + takahashi
	takahashi = 0
else:
	takahashi = takahashi - count
if aoki < 0:
	aoki = 0
print(takahashi,aoki)

Solution (Python):
ta,ao,k = map(int,input().split())

if ta < k: 
    k = k - ta
    ta = 0

else: 
    ta = ta - k
    k = 0

if ao < k:
    ao = 0
    k = k - ao

else:
    ao = ao - k
    k = 0

print(ta,ao)

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

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

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

ans_a = max((a - k), 0)
if ans_a == 0:
    ans_b = max((a + b) - k, 0)
else:
    ans_b = b
print(str(ans_a) + " " + str(ans_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)
elif K <= A + B:
    print(0, B - K + A)
else:
    print(0, 0)

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

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

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

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

Solution (Python):
def solve():
  a,b,k = (int(i) for i in input().split())
  caneat = min(k,a+b)
  ans = [0,b]
  if a <= caneat:
    ans[0] = 0
    ans[1] = b-(caneat-a)
  else:
    ans[0] = a-caneat
  print(*ans)
solve()

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

Solution (Python):
A, B, K = map(int, input().split())
if A >= K:
    A -= K
    print(A, B, sep=" ")
    exit()

K -= A
A = 0
B = max(B - K, 0)
print(A, B, sep=" ")

Solution (Python):



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


resA = max(0, A - K)
resB = max(0, B - max(0, K - A))


print(resA, resB)

Solution (Python):


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


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

print(a, b)

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

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

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

print(A, B)

Solution (Python):
def main():
  [a, t, k] = [int(i) for i in input().split()]
  if a + t <= k:
    a = 0
    t = 0
  elif a <= k:
    t = t - (k - a)
    a = 0
  else:
    a = a - k
  print(a, t)

if __name__ == "__main__":
  main()

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

Solution (Python):


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

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

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

Solution (Python):
from sys import stdin
a,b,k = [int(x) for x in stdin.readline().rstrip().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,c = map(int,input().split())

if(a<=c):
    p = 0
    if(b<=c-a):
        q = 0
    else:
        q = b -(c-a)
else:
    p = a-c
    q = int(b)

print(str(p) + " " + str(q))

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

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

print(a,b)

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,c=map(int,input().split())
x=max(0,a-c)
bb=max(0,c-a)
print(x,max(0,b-bb))

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):
list = input().split(' ')
(A,B,K)=(int(list[0]),int(list[1]),int(list[2]))
if A >= K:
    A = A - K
elif 1 <= A < K:
    B = B - K + A
    if B < 0:
        B = 0
    A = 0
else:
    A = 0
    B = B - K
    if B < 0:
        B = 0
print(A,B)

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

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

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

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

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

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

ans = [None] * 2

ans[0] = str(max(A - K, 0))
ans[1] = str(max(B - max(K - A, 0), 0))

print(" ".join(ans))

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

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

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


print(A, B)

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

if a+b <= k:
  a=0
  b=0
elif a <= k < a+b:
  b=a+b-k
  a=0
else:
  a=a-k
print(' '.join([str(a), str(b)]))

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

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

Solution (Python):
'''
import math
import fractions

def make_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

def bitlist(x,digit):
    res = [0 for i in range(digit)]
    now = x
    for i in range(digit):
        res[i]=now%2
        now = now >> 1
    return res
'''

'''
n,m,t = list(map(int, input().split()))

nb = [[] for i in range(n+1)]
for i in range(n):
    a,b = list(map(int, input().split()))
    nb[a].append([b,i])
    nb[b].append([a,i])
print(nb)

order = [-1 for i in range(n+1)]
order[1] = 0
noworder = 1
nbnow = [len(nb[i])-1 for i in range(n+1)]

print(nbnow)
queue = [[1,999999]]
deque = 0

while(len(queue)>deque and len(queue)<20):
    nownum = queue[deque][0]
    nowpos = queue[deque][1]
    deque+=1
    print("a",nownum,nowpos)
    while(True):
        if(nb[nownum][nbnow[nownum]][1] > nowpos):
            nbnow[nownum] -= 1
        if(nbnow[nownum]<=-1):
            break
    if(nbnow[nownum]<=-1):
        continue
    
    nextnum = nb[nownum][nbnow[nownum]][0]
    nextpos = nb[nownum][nbnow[nownum]][1]
    print(nextnum,nextpos)
    if(order[nextnum]==-1):
        queue.append([nextnum,nextpos])
        order[nextnum]=noworder
        noworder+=1


print(order)
'''



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

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

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

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

Solution (Python):
n = list(map(int,input().split()))
ans1 = n[0] - n[2]
ans2 = (n[0] + n[1]) -  n[2]

if ans1 <= 0:
    ans1 = 0

if ans1 > 0:
    ans2 = n[1]
elif ans2 <= 0:
    ans2 = 0

print(ans1,ans2)

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

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

Solution (Python):
takahashi, aoki, count = map(int, input().split())
if takahashi >= count:
    takahashi -= count
elif takahashi < count and aoki > count - takahashi:
    aoki -= count - takahashi
    takahashi = 0
    
else:
    takahashi, aoki = 0, 0
print(takahashi, aoki)

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

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

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

if a > k:
  aa = a - k
  bb = b

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

print(aa , bb)

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

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

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

takahashi_cookie = A
aoki_cookie = B
iteration = K

if 0 <= takahashi_cookie - iteration:
  takahashi_cookie -= iteration
 
elif 0 <= aoki_cookie + takahashi_cookie - iteration:
  aoki_cookie = aoki_cookie + takahashi_cookie - iteration
  takahashi_cookie = 0

else:
  takahashi_cookie = 0
  aoki_cookie = 0

print(str(takahashi_cookie) + ' ' + str(aoki_cookie))

Solution (Python):
import sys
def fastio():
    from io import StringIO
    from atexit import register
    global input
    sys.stdin = StringIO(sys.stdin.read())
    input = lambda : sys.stdin.readline().rstrip('\r\n')
    sys.stdout = StringIO()
    register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()

def debug(*var, sep = ' ', end = '\n'):
    print(*var, file=sys.stderr, end = end, sep = sep)

INF = 10**20
MOD = 10**9 + 7
I = lambda:list(map(int,input().split()))

from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br

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

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

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=[int(i) for i in input().split()]
k=a[2]
if(a[0]<=k):
    k-=a[0]
    a[0]=0
else:
    a[0]-=k
    k=0
if(k>0):
    if(a[1]>k):
        a[1]-=k
    else:
        a[1]=0
print(a[0],a[1])

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

Solution (Python):
taka, aoki, action = map(int, input().split())
 
if taka >= action:
  print(taka-action, aoki)
  
else:
  print(0, max(taka+aoki-action, 0))

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

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

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

temp_a = a
if (k >= a):
  a = 0
else :
  a = (a - k)
k = k - temp_a

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


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

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

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

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

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

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

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

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

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

Solution (Python):



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

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


if __name__ == '__main__':
    main()

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

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

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

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

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

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

S=max([0,A-K])

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

else:
  T=B

print(str(S)+" "+str(T))

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

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

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

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

mi = min(A, K)
A -= mi
K -= mi
mi = min(B, K)
B -= mi

print A, B

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

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

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

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

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

Solution (Python):
input_line = input().split(' ')
taka = int(input_line[0])
aoki = int(input_line[1])
numK = int(input_line[2])
result = ""
if taka + aoki <= numK:
  result = "0 0"
elif taka >= numK:
  result = str(taka - numK) + " " + str(aoki)
elif taka + aoki > numK:
  result = "0 " + str(taka + aoki - numK)
  
print(result)

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
 
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7


def gcd(a, b):
	if a < b:
		a, b = b, a
	while a % b != 0:
		a, b = b, a % b
	return b
 

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

a, b, k = MAP()

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

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

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

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

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

p=0
q=0

if k<=a:
    p=a-k
    q=b
elif k-a<=b:
    p=0
    q=b-(k-a)
else:
    p=0
    q=0

print("{} {}".format(p, q))

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

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

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

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

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

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

X = max(0, A - K)
Y = max(0, min(A + B - K, B))

print(X, Y)

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

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

Solution (Python):

import numpy as np
from functools import lru_cache
import time

def main(): 
    if True:
        A,B,K = list(map(
            int, input().split()))
    else:
        pass

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



if __name__ =='__main__':
    main()

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

Solution (Python):
def solve(a, b, k):
    d = min(a, k)
    a -= d
    k -= d
    d = min(b, k)
    b -= d
    return "%d %d" % (a, b)

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

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

Solution (Python):
A,B,K = map(int, input().split())
if A >= 1:
    if K - A >= 0:
        K = K - A
        A = 0
        if K - B >= 0:
            B = 0
        else:
            B = B - K
    else:
        A = A - K
else:
    if K - B >= 0:
        B = 0
    else:
        B = B - K
print("{} {}".format(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):
s = list(map(int,input().split()))
a = 0
if s[2] >= s[0]:
    a = s[2] - s[0]
    s[0] = 0
    if a >= s[1]:
        s[1] = 0
    else:
        s[1] = s[1] - a
else:
    s[0] = s[0] - s[2]

print(str(s[0]) + ' ' + str(s[1]))

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

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

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

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

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

if a + b <= k:
    a = b = 0
elif a < k and k < a + b:
    b = b + a - k
    a = 0
else:
    a -= k

print(a, b)

Solution (Python):



if __name__=='__main__':
  a, b, k = map(int, input().strip().split())
  print(max(0, a-k), max(0, b-max(0, k-a)))