#include <bits/stdc++.h>
using namespace std;

#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for(int64 i = 0;i < (n);i++)
#define FOR(i, a, b) for(int64 i = (a);i < (b);i++)
#define all(x) x.begin(),x.end()
#define fs first
#define sc second

using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;

const double eps = 1e-10;

template<typename A, typename B>inline void chmin(A &a, B b){if(a > b) a = b;}
template<typename A, typename B>inline void chmax(A &a, B b){if(a < b) a = b;}

template<typename T>
vector<T> make_v(size_t a){return vector<T>(a);}

template<typename T,typename... Ts>
auto make_v(size_t a,Ts... ts){
	return vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));
}

template<typename T,typename U,typename... V>
typename enable_if<is_same<T, U>::value!=0>::type
fill_v(U &u,const V... v){u=U(v...);}

template<typename T,typename U,typename... V>
typename enable_if<is_same<T, U>::value==0>::type
fill_v(U &u,const V... v){
	for(auto &e:u) fill_v<T>(e,v...);
}


template<class ValueMonoid, class OperatorMonoid, class Modifier,
  template<class...> class Container=::std::vector>
class LazySegTree{
public:
  using value_structure = ValueMonoid;
  using value_type = typename value_structure::value_type;
  using operator_structure = OperatorMonoid;
  using operator_type = typename operator_structure::value_type;
  using modifier = Modifier;
  using const_reference = const value_type &;
  using container_value_type = Container<value_type>;
  using container_operator_type = Container<operator_type>;
  using size_type = typename container_value_type::size_type;

private:
  container_value_type tree;
  container_operator_type lazy;
  size_type size_, height;

  static size_type getsize(const size_type x){
    size_type ret = 1;
    while(ret < x)
      ret <<= 1;
    return ret;
  }

  static size_type getheight(const size_type x){
    size_type ret = 0;
    while((static_cast<size_type>(1) << ret) < x){
      ret++;
    }
    return ret;
  }

  inline static value_type calc(const value_type a, const value_type b){
    return value_structure::operation(a, b);
  }

  inline static void apply(operator_type &data, const operator_type a){
    data = operator_structure::operation(data, a);
  }

  inline static value_type reflect(const value_type v, const operator_type o){
    return modifier::operation(v, o);
  }

  void push(const size_type index){
    tree[index] = reflect(tree[index], lazy[index]);
    apply(lazy[index << 1], lazy[index]);
    apply(lazy[index << 1 | 1], lazy[index]);
    lazy[index] = operator_structure::identity();
  }

  void calc_node(const size_type index){
    if(tree.size() <= (index << 1 | 1)) return;
    assert(0 < index);
    tree[index] = calc(reflect(tree[index << 1],  lazy[index << 1]),
                       reflect(tree[index << 1 | 1], lazy[index << 1 | 1]));
  }

  void build(size_type index){
    while(index >>= 1){
      calc_node(index);
    }
  }

  void propagate(const size_type index){
    for(size_type shift = height; shift ; --shift){
      push(index >> shift);
    }
  }

  void rebuild(){
    for(size_type i = size_-1;i > 0;--i){
      calc_node(i);
    }
  }
public:
  LazySegTree() : size_(0), height(0), tree(), lazy(){}
  LazySegTree(const size_type size)
    : size_(size), height(getheight(size)),
      tree(size << 1, value_structure::initializer()),
      lazy(size << 1, operator_structure::identity()){
    rebuild();
  }
  template<class InputIterator>
  LazySegTree(InputIterator first, InputIterator last)
    : size_(::std::distance(first, last)){
    height = getheight(size_);
    tree = container_value_type(size_, value_structure::identity());
    lazy = container_operator_type(size_ << 1, operator_structure::identity());
    tree.insert(tree.end(), first, last);
    rebuild();
  }

  size_type size() const { return size_; }
  const_reference operator[](const size_type k){
    assert(k < size_);
    propagate(k+size_);
    tree[k+size_] = reflect(tree[k+size_], lazy[k+size_]);
    lazy[k+size_] = operator_structure::identity();
    return tree[k+size_];
  }

  value_type query(size_type l, size_type r){
    assert(l <= r);
    assert(0 <= l && l < size_);
    assert(0 <= r && r <= size_);
    value_type retl = value_structure::identity(),
      retr = value_structure::identity();
    l += size_;
    r += size_;
    propagate(l);
    propagate(r-1);
    build(l);
    build(r-1);
    for(; l < r ; l >>= 1, r >>= 1){
      if(l&1){
        retl = calc(retl, reflect(tree[l], lazy[l]));
        l++;
      }
      if(r&1){
        r--;
        retr = calc(reflect(tree[r], lazy[r]), retr);
      }
    }
    return calc(retl, retr);
  }

  void update(size_type l, size_type r, const operator_type& data){
    assert(l <= r);
    assert(0 <= l && l < size_);
    assert(0 <= r && r <= size_);
    l += size_;
    r += size_;
    propagate(l);
    propagate(r - 1);
    for(size_type l_ = l, r_ = r; l_ < r_ ; l_ >>= 1, r_ >>= 1){
      if(l_ & 1) apply(lazy[l_++], data);
      if(r_ & 1) apply(lazy[--r_], data);
    }
    build(l);
    build(r - 1);
  }

  template<class F>
  void update(size_type index, const F& f){
    assert(0 <= index && index < size());
    index += size_;
    propagate(index);
    tree[index] = f(::std::move(tree[index]));
    lazy[index] = operator_structure::identity();
    build(index);
  }

  /*
  template<class F>
  size_type search(const F& f) const { // [0, result) is True and [0, result-1) is not.
    if(f(value_structure::identity()))
      return 0;
    if(!f(tree[1]))
      return size_+1;
    value_type acc = value_structure::identity();
    size_type i = 1;
    while(i <
  }
  */
};

template<::std::uint_fast64_t mod>
class ModInt{
private:
  using value_type = ::std::uint_fast64_t;
  value_type n;
public:
  ModInt() : n(0) {}
  ModInt(value_type n_) : n(n_ % mod) {}
  ModInt(const ModInt& m) : n(m.n) {}

  template<typename T>
  explicit operator T() const { return static_cast<T>(n); }
  value_type get() const { return n; }

  friend ::std::ostream& operator<<(::std::ostream &os, const ModInt<mod> &a) {
    return os << a.n;
  }

  friend ::std::istream& operator>>(::std::istream &is, ModInt<mod> &a) {
    value_type x;
    is >> x;
    a = ModInt<mod>(x);
    return is;
  }

  bool operator==(const ModInt& m) const { return n == m.n; }
  bool operator!=(const ModInt& m) const { return n != m.n; }
  ModInt& operator*=(const ModInt& m){ n = n * m.n % mod; return *this; }

  ModInt pow(value_type b) const{
    ModInt ans = 1, m = ModInt(*this);
    while(b){
      if(b & 1) ans *= m;
      m *= m;
      b >>= 1;
    }
    return ans;
  }

  ModInt inv() const { return (*this).pow(mod-2); }
  ModInt& operator+=(const ModInt& m){ n += m.n; n = (n < mod ? n : n - mod); return *this; }
  ModInt& operator-=(const ModInt& m){ n += mod - m.n; n = (n < mod ? n : n - mod); return *this; }
  ModInt& operator/=(const ModInt& m){ *this *= m.inv(); return *this; }
  ModInt operator+(const ModInt& m) const { return ModInt(*this) += m; }
  ModInt operator-(const ModInt& m) const { return ModInt(*this) -= m; }
  ModInt operator*(const ModInt& m) const { return ModInt(*this) *= m; }
  ModInt operator/(const ModInt& m) const { return ModInt(*this) /= m; }
  ModInt& operator++(){ n += 1; return *this; }
  ModInt& operator--(){ n -= 1; return *this; }
  ModInt operator++(int){
    ModInt old(n);
    n += 1;
    return old;
  }
  ModInt operator--(int){
    ModInt old(n);
    n -= 1;
    return old;
  }
  ModInt operator-() const { return ModInt(mod-n); }
};

class HLDecomposition{
private:
  std::vector<std::vector<int_fast32_t>> G;
  std::vector<int_fast32_t> vid, inv, dep, par, typ, sub, head, in, out;
  size_t n, pos;
public:
  HLDecomposition(){}
  HLDecomposition(size_t n):
    n(n), pos(0), G(n), vid(n, -1), inv(n), dep(n, -1),
    par(n), typ(n), sub(n, 1), head(n), in(n, -1), out(n, -1){}

  void add_edge(uint_fast32_t u, uint_fast32_t v){
    G[u].push_back(v);
    G[v].push_back(u);
  }

  void build(){
    uint_fast32_t type = 0;
    for(int_fast32_t i = 0;i < n;i++){
      if(dep[i] == -1){
        dfs(i);
        dfs2(i, type++, i);
      }
    }
  }

  void dfs(uint_fast32_t v){
    using T = std::pair<uint_fast32_t, uint_fast32_t>;
    dep[v] = 0;
    par[v] = -1;
    std::stack<T> st;
    st.emplace(v, 0);
    while(st.size()){
      v = st.top().first;
      uint_fast32_t &i = st.top().second;
      if(i<G[v].size()){
        uint_fast32_t u = G[v][i++];
        if(u == par[v]) continue;
        par[u] = v;
        dep[u] = dep[v]+1;
        st.emplace(u, 0);
      }else{
        st.pop();
        for(int_fast32_t &u : G[v]){
          if(u == par[v]) continue;
          sub[v] += sub[u];
          if(G[v][0] == par[v] || sub[u] > sub[G[v][0]]){
            std::swap(u, G[v][0]);
          }
        }
      }
    }
  }

  void dfs2(uint_fast32_t v, uint_fast32_t t, uint_fast32_t h){
    typ[v] = t;
    in[v] = pos;
    out[v] = in[v]+sub[v]-1;
    vid[v] = pos++;
    inv[vid[v]] = v;
    head[v] = h;
    for(uint_fast32_t u : G[v]){
      if(u == par[v]) continue;
      if(u == G[v][0])
        dfs2(u, t, h);
      else
        dfs2(u, t, u);
    }
  }

  void for_each(uint_fast32_t u, uint_fast32_t v, const std::function<void(uint_fast32_t, uint_fast32_t)>& f){
    while(1){
      if(vid[u] > vid[v]) std::swap(u, v);
      f(std::max(vid[head[v]], vid[u]), vid[v]);
      if(head[u] != head[v]) v=par[head[v]];
      else break;
    }
  }

  void for_each_edge(uint_fast32_t u, uint_fast32_t v, const std::function<void(uint_fast32_t, uint_fast32_t)>& f){
    while(1){
      if(vid[u] > vid[v]) std::swap(u, v);
      if(head[u] != head[v]){
        f(vid[head[v]], vid[v]);
        v = par[head[v]];
      }else{
        if(u!=v) f(vid[u]+1, vid[v]);
        break;
      }
    }
  }

  void for_subtree(uint_fast32_t u, const std::function<void(uint_fast32_t, uint_fast32_t)>& f){
    if(in[u] == -1){
      std::cout << "Invalid vertex." << std::endl;
      return;
    }
    f(in[u], out[u]);
  }

  uint_fast32_t lca(uint_fast32_t u, uint_fast32_t v){
    while(1){
      if(vid[u] > vid[v]) std::swap(u, v);
      if(head[u] != head[v]) v = par[head[v]];
      else return u;
    }
  }

  uint_fast32_t distance(uint_fast32_t u, uint_fast32_t v){
    uint_fast32_t ret = dep[u]+dep[v]-2*dep[lca(u, v)];
    assert(ret >= 0);
    return ret;
  }

  uint_fast32_t getvid(uint_fast32_t v){
    return vid[v];
  }
};

constexpr int64 mod = 998244353;
using Mint = ModInt<mod>;

class v_monoid {
public:
  using value_type = Mint;
  static Mint identity() { return 0; }
  static Mint initializer() { return 0; }
  static Mint operation(const Mint& a, const Mint& b) {
    return a + b;
  }
};

class o_monoid {
public:
  using value_type = Mint;
  static Mint identity() { return 0; }
  static Mint operation(const Mint& a, const Mint &b ) {
    return a + b;
  }
};

class modifier {
public:
  static Mint operation (const Mint& a, const Mint& b) {
    return a + b;
  }
};

vector<int64> sz;
vector<int64> G[151234];

void dfs(int v = 0, int p = -1) {
  sz[v] = 1;
  REP(i, G[v].size()) {
    if (G[v][i] == p) continue;
    dfs(G[v][i], v);
    sz[v] += sz[G[v][i]];
  }
}

int main(void) {
  cin.tie(0);
  ios::sync_with_stdio(false);
  int64 A, B, K;
  cin >> A >> B >> K;
  cout << max((int64)0, A-K) << " " << max((int64)0, B - max(K-A, (int64)0)) << endl;
}


Measured memory_bytes: 3840