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

int main() {
  ld a, b, c;
  cin >> a >> b >> c;

  ll X = round(a * 10000);
  ll Y = round(b * 10000);
  ll R = round(c * 10000);
  
  vector<string> str;
  ll ans = 0;
  ll x_s =  ceil((X-R)/10000.0)*10000;
  ll x_e = floor((X+R)/10000.0)*10000;
  
  for (int i=x_s; i<=x_e; i+=10000) {
    
    ld rt = sqrtl( (ld)R*(ld)R - ((ld)i-(ld)X)*((ld)i-(ld)X) );
    ll j_large = floor(((ld)Y+ rt )/10000.0)*10000;
    ll j_small =  ceil(((ld)Y- rt )/10000.0)*10000;
    
    ans += (j_large - j_small) /10000 + 1;
  }
  
  
  
  
  cout << ans << endl;
  return 0;
}
// {{{ by unolight
#include <bits/stdc++.h>
#include <unistd.h>
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC diagnostic ignored "-Wunused-function"
#define SZ(x) ((int)(x).size())
#define ALL(x) begin(x),end(x)
#define RALL(x) rbegin(x),rend(x)
#define REP(i,n) for ( int i=0; i<int(n); i++ )
#define REP1(i,a,b) for ( int i=(a); i<=int(b); i++ )
#define MP make_pair
#define PB push_back
using namespace std;
typedef int64_t LL;
typedef pair<int,int> PII;
typedef vector<int> VI;

namespace { namespace unolight {
// Read Input
template<class T> void _R( T &x ) { cin>>x; }
void _R( int &x ) { scanf("%d",&x); }
void _R( int64_t &x ) { scanf("%" PRId64,&x); }
void _R( double &x ) { scanf("%lf",&x); }
void _R( char &x ) { scanf(" %c",&x); }
void _R( char *x ) { scanf("%s",x); }
void R() {}
template<class T, class... U> void R( T& head, U&... tail ) { _R(head); R(tail...); }
// Write Output
template<class T> void _W( const T &x ) { cout<<x; }
void _W( const int &x ) { printf("%d",x); }
void _W( const int64_t &x ) { printf("%" PRId64,x); }
void _W( const double &x ) { printf("%.16f\n",x); }
void _W( const char &x ) { putchar(x); }
void _W( const char *x ) { printf("%s",x); }
template<class T> void _W( const vector<T> &x ) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }
void W() {}
template<class T, class... U> void W( const T& head, const U&... tail ) { _W(head); putchar(sizeof...(tail)?' ':'\n'); W(tail...); }

#ifdef UNOLIGHT
#include "dump.hpp"
#else
#define dump(...)
#endif

template<class T> inline bool chmax( T &a, const T &b ) { return b>a ? a=b,true : false; }
template<class T> inline bool chmin( T &a, const T &b ) { return b<a ? a=b,true : false; }
template<class T> using MaxHeap = priority_queue<T>;
template<class T> using MinHeap = priority_queue<T, vector<T>, greater<T>>;
template<class T, class F=less<T>> void sort_uniq( vector<T> &v, F f=F() ) {
    sort(begin(v),end(v),f);
    v.resize(unique(begin(v),end(v))-begin(v));
}
// }}}

// 1 unit is 10000
const int K=10000;
LL x,y,r;
void input() {
    double a,b,c;
    R(a,b,c);
    x=round(abs(a)*K);
    y=round(abs(b)*K);
    r=round(abs(c)*K);
}
bool in( LL a, LL b ) {
    return (a-x)*(a-x)+(b-y)*(b-y)<=r*r;
}
LL solve( LL lim ) {
    LL l=0,r=1;
    LL res=0;
    for ( int j=(int)(1e9)+K; j>=lim; j-=K ) {
        while ( in(l*K,j) ) l--;
        while ( in(r*K,j) ) r++;
        res+=r-l-1;
    }
    return res;
}
void main() {
    input();
    // make center between 0 ~ 1
    x%=K;
    y%=K;
    LL ans=0;
    // solve upper part
    ans+=solve(K);
    // solve bottom part
    y=-y; // let bottom part be upper
    ans+=solve(0);
    W(ans);
}

 // {{{ main
}}
int main() { unolight::main(); return 0; }
// }}}
