#include "bits/stdc++.h"

using namespace std;
using ll = long long;

void Main() {
    double A, B, W;
    cin >> A >> B >> W;
    W *= 1000;

    double minimum = W / B;
    double maximum = W / A;

    bool foundMin = false;
    bool foundMax = false;
    int minInt = 1000000000;
    int maxInt = -1;
    for (int i = 1; i < 1001000; ++i) {
        if (minimum <= i && i <= maximum) {
            minInt = min(minInt, i);
            maxInt = max(maxInt, i);
        }
    }
    if (maxInt < 0) {
        cout << "UNSATISFIABLE" << endl;
    }
    else {
        cout << minInt << " " << maxInt << endl;
    }
}

int main() {
    std::cout << std::fixed << std::setprecision(15);
    Main();
    return 0;
}

/*
   Author   : MatsuTaku
   Date     : 02/18/21
*/

#include <bits/stdc++.h>
using namespace std;
#include <x86intrin.h>
#ifndef ONLINE_JUDGE
#define Assert(cond)      assert(cond)
#else
#define Assert(cond)
#endif
#define rep(i, n)         for (size_t i = 0, i##_len = (n); i < i##_len; i++)
using lint = long long int;
template<typename T>
using vvec = vector<vector<T>>;
template<typename T>
vvec<T> make_vvec(int n, int m, T v) { return vvec<T>(n, vector<T>(m, v)); }
template<typename T>
void chmax(T& dst, T x) { dst = max(dst, x); }
template<typename T>
void chmin(T& dst, T x) { dst = min(dst, x); }

class Solver {
 public:
  Solver();
  void solve();
};

Solver::Solver() {}

constexpr lint scale = 10000;
void Solver::solve() {
  double _x,_y,_r; cin>>_x>>_y>>_r;
  lint x = (lint) round(_x*scale);
  lint y = (lint) round(_y*scale);
  lint r = (lint) round(_r*scale);
  lint p = (x-r)/scale * scale;
  lint ans = 0;
  while (p <= x+r) {
    if (p < x-r) {
      p += scale;
      continue;
    }
    lint dx = abs(x-p);
    lint dy = sqrt(r*r-dx*dx);
//    while ((dy+1)*(dy+1) + dx*dx <= r*r) dy++;
    while (dy*dy + dx*dx > r*r) dy--;
    lint by = y - dy - 1, ty = y + dy;
    if (by < 0) {
      lint add = (-by/scale+1) * scale;
      by += add;
      ty += add;
    }
    ty /= scale;
    by /= scale;
    ans += ty-by;
    p += scale;
  }
  cout << ans << endl;
}

int main() {
  cin.tie(nullptr); ios::sync_with_stdio(false);
  cout<<fixed<<setprecision(10);
  Solver solver;
  int t = 1;
//  cin>>t;
  while (t--) {
    solver.solve();
  }
  return 0;
}
