#include <bits/stdc++.h>

int64_t sqrt(int64_t x) {
    int64_t l = 0, r = 2e9;
    while (l < r) {
        int64_t m = (l + r) / 2;
        if (m * m > x) {
            r = m;
        }
        else {
            l = m + 1;
        }
    }
    return l - 1;
}

int64_t ceil(int64_t _x, int64_t _y) {
    if (_y < 0) {
        _x = -_x;
        _y = -_y;
    }
    if (_x < 0) return _x / _y;
    return (_x + _y - 1) / _y;
}

int64_t floor(int64_t _x, int64_t _y) {
    if (_y < 0) {
        _x = -_x;
        _y = -_y;
    }
    if (_x >= 0) return _x / _y;
    return (_x - _y + 1) / _y;
}

signed main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    long double _x, _y, _r;
    std::cin >> _x >> _y >> _r;

    int64_t x = std::round(10000 * _x);
    int64_t y = std::round(10000 * _y);
    int64_t r = std::round(10000 * _r);

    int64_t c = ceill(_y - _r), d = floorl(_y + _r), ans = 0;

    for (int i = std::ceil(_x - _r); i <= std::floor(_x + _r); i++) {
        int64_t sq = sqrt(r * r - (10000 * i - x) * (10000 * i - x));

        int64_t e = std::max(ceil(y - sq, 10000), c);
        int64_t f = std::min(floor(y + sq, 10000), d);
        ans += std::max(f - e + 1, 0L);
    }

    printf("%jd\n", ans);

    return 0;
}
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using ld = long double;

ll in() {
  ld x;
  cin >> x;
  x *= 10000;
  return round(x);
}

bool ok(ll dx, ll dy, ll z) { return dx * dx + dy * dy <= z * z; }

ll f(ll x, ll y, ll z, ll lim) {
  ll l = 0, r = 1, res = 0;
  for (int i = int(1e9) + 50000; i >= lim; i -= 10000) {
    while (ok(x - l * 10000, i - y, z)) l--;
    while (ok(r * 10000 - x, i - y, z)) r++;
    res += r - l - 1;
  }
  return res;
}

int main() {
  ll x = in();
  ll y = in();
  ll r = in();
  x %= 10000;
  y %= 10000;

  ll ans = f(x, y, r, 10000);
  ans += f(x, -y, r, 0);
  cout << ans << endl;
  return 0;
}