#include <math.h>

#include <algorithm>
#include <array>
#include <bitset>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <vector>

using namespace std;
using Graph = vector<vector<int>>;

using ll = long long;
typedef pair<ll, ll> P_ll;
typedef pair<int, int> P;

const ll INF_ll = 1e17;
const int INF = 1e8;

ll sqrt_ll(ll n) {
  ll l = 0LL;
  ll r = 1e9 + 10;
  while (r - l > 1LL) {
    ll m = (l + r) / 2;
    if (m * m > n)
      r = m;
    else
      l = m;
  }
  return l;
}

int main() {
  long double X, Y, R;
  cin >> X >> Y >> R;
  const ll a = 10000;
  X *= (long double)a;
  Y *= (long double)a;
  R *= (long double)a;
  X = roundl(X);
  Y = roundl(Y);
  R = roundl(R);
  ll x = (ll)X;
  ll y = (ll)Y;
  ll r = (ll)R;

  ll s = (x - r) / a;
  if (s * 10000 < x - r) {
    s++;
  }
  ll ans = 0;
  for (ll i = s * a; i <= x + r; i += a) {
    ll p = r * r - (x - i) * (x - i);
    ll q = sqrtl(p);
    ll b = (y - q) / a;
    if (b * a < y - q) {
      b++;
    }
    ll c = (y + q) / a;
    if (c * a > y + q) {
      c--;
    }
    ans += (c * a - b * a) / a + 1;
  }

  cout << ans << endl;

  return 0;
}
#include<bits/stdc++.h> // 57 68 "Baklol, Take it easy"
using namespace std;

#define rep(x, k, n)        for(int x = (k); x < (n); ++x)
#define repr(x, k, n)       for(int x = (k); x > (n); --x)
#define tr(it, a)           for(auto it = (a).begin(); it != (a).end(); ++it)
#define ll                  long long
#define siz(x)              ((int)(x).size())
#define pb                  push_back
#define mp                  make_pair
#define F                   first
#define S                   second
#define o2(x)               ( (x) * (x) )
#define all(x)              (x).begin(), (x).end()
#define clr(x, k)           memset(x, k, sizeof(x)) // 0, -1
#define sortall(x)          sort(all(x))
#define sortalld(x)         sort(all(x), greater<int>())
#define printv(v, x)        rep(i, 0, x) cout << v[i] << " \n"[i+1==x];
#define print2dv(V, y, x)   rep(j, 0, y) printv(V[j], x);
#define out(x)              cout << ((x) ? "Yes" : "No") << '\n'
#define setbits(x)          __builtin_popcountll(x)
#define inf                 INT_MAX
#define ninf                INT_MIN
#define int                 long long // "be carefull"

typedef pair<int, int>      pii;
typedef vector<int>         vi;
typedef vector<bool>        vb;
typedef vector<pii>         vpii;
typedef vector<vi>          vvi;
typedef vector<vb>          vvb;

template <typename Arg1>
void debug_out(const char* name, Arg1&& arg1){
    cout << name << " = " << arg1  << " ]" << '\n';
}
template <typename Arg1, typename... Args>
void debug_out(const char* names, Arg1&& arg1, Args&&... args){
    const char* comma = strchr(names + 1, ',');
    cout.write(names, comma - names) << " = " << arg1 <<",";
    debug_out(comma+1, args...);
}

#ifndef ONLINE_JUDGE
#define deb(...) cout << "[ ", debug_out(#__VA_ARGS__, __VA_ARGS__)
#else
#define deb(...)
#endif

const int mod = 1e9 + 7; // 998244353;
const int N = 3e5 + 5, M = N;

//-----------------------------------------------------------------------------

void Solve_main() {
    int a, b, c, d;
    cin >> a >> b >> c >> d;
    cout << min({a, b, c, d});
}

//-----------------------------------------------------------------------------

int32_t main() {
    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    srand(chrono::high_resolution_clock::now().time_since_epoch().count());

    // cout << setprecision(12) << fixed;
    int tc = 1;
    // cin >> tc;
    for(int i = 0; i < tc; i++) {
        Solve_main();
    }

    cerr << "[time:" << 1.0*clock()/CLOCKS_PER_SEC << "s] ";
    return 0;
}

/*
-> edge cases.
-> Submit - right file.
-> Move on - if completely_stuck > 30 minute.
-> entire input - multiple testcases.
-> time complexity - 1 sec : 4e8 will work but risky.
-> space complexity - 256 mb : 6e7(int), 3e7(ll), 2e8(bool, char),  will work.
-> mod.
-> builtin fuction - add ll.
-> Iterative > Recursive.
-> clear - global variables.
*/