#include<bits/stdc++.h>

using i28 = __int128_t;

using namespace std;
// using i28 = long long;
using pint = pair<i28,i28>;
const i28 G = 10000;
const i28 lim = 2e9;
// #include"debug.hpp"


ostream &operator<<(ostream &dest, __int128_t value) {
  ostream::sentry s(dest);
  if (s) {
	__uint128_t tmp = value < 0 ? -value : value;
	char buffer[128];
	char *d = std::end(buffer);
	do {
	  --d;
	  *d = "0123456789"[tmp % 10];
	  tmp /= 10;
	} while (tmp != 0);
	if (value < 0) {
	  --d;
	  *d = '-';
	}
	int len = std::end(buffer) - d;
	if (dest.rdbuf()->sputn(d, len) != len) {
	  dest.setstate(ios_base::badbit);
	}
  }
  return dest;
}

__int128 parse(string &s) {
  __int128 ret = 0;
  for (int i = 0; i < (int)s.length(); i++)
	if ('0' <= s[i] && s[i] <= '9')
	  ret = 10 * ret + s[i] - '0';
  return ret;
}

istream &operator>>(istream &is, __int128_t &a){
	string s;
	is>>s;
	a = parse(s);
	return (is);
}
// using Int = __int128_t;




i28 in() {
	string s; cin >> s;

	auto itr = find(s.begin(), s.end(), '.');
	if(itr == s.end()) return stoi(s) * G;
	i28 idx = s.end() - itr;
	s.erase(itr);
	if(count(s.begin(), s.end(), '0') == (i28)s.size()) return 0;
	while(s.front() == '0') s.erase(s.begin());
	i28 x = stoi(s);
	i28 coef = 1;
	for(i28 i = 0; i < 5 - idx; i++)coef *= 10;
	return x * coef;
}




i28 f(i28 rem, i28 y) {
	i28 lower, upper;
	{ //lower
		i28 lef = -1e18, rig = y; //xxxxooo
		while(rig - lef  > 1) {
			i28 mid = (lef + rig) / 2;
			(mid * (mid - 2 * y) <= rem ? rig : lef) = mid;
		}
		lower = rig;
	}
	{
		i28 lef = y, rig = 1e18; //oooooxxx
		while(rig - lef > 1) {
			i28 mid = (lef + rig) / 2;
			(mid * (mid - 2 * y) <= rem ? lef : rig) = mid;
		}
		upper = lef;
	}

	auto myci = [&](i28 num) {
		if(num <= 0) return -(-num + G - 1) / G;
		else return num / G;
	};

	i28 lownum = myci(lower-1);
	i28 uppnum = myci(upper);
	// print(lower, upper, lownum, uppnum);

	return uppnum - lownum;
} 

int main()
{
	i28 x, y, r;
	x = in();
	y = in();
	r = in();
	// print(x, y, r);

	i28 r2 = (i28)r * r;
	i28 num = 0;
	for(i28 t1 = -lim; t1 <= lim; t1 += G) {
		i28 xa = (i28)(t1 - x) * (t1 - x);
		if(xa > r2) continue;
		// print(t1);
		i28 rem = r2 - xa;
		// print(rem);
		rem -= (i28)y * y;

		num += f(rem, y);
		// print(num, rem);
	}

	cout << num << endl;

}
#include <algorithm>
#include <iostream>
#include <vector>
#include <map>
#include <cstdio>
#include <string>
#include <cmath>
#include <queue>
#include <tuple>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <random>
#include <set>
#include <stack>
#include <time.h>
#include <unordered_map>

//#include <bits/stdc++.h>
#define maxs(x,y) x = max(x,y)
#define mins(x,y) x = min(x,y)
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define repr(i, n) for (int i = (n) - 1; i >= 0; i--)
#define FOR(i,i0,n) for(int (i)=(i0);(i)<(n);(i)++)
#define FORR(i,i0,n) for(int (i)=(n)-1; (i)>=(i0);(i)--)
#define SORT(x) sort(x.begin(),x.end())
#define SORTR(x) sort(x.begin(),x.end(),greater<int>())

#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple

using namespace std;
using ll = long long;
typedef std::pair<int, int> pii;
typedef std::pair<int, double> pid;
typedef std::vector<int> vi;
typedef std::vector<pii> vii;
#define PI 3.14159265358979323846264338327950L

const int mod = 1000000007;


struct container{
    int bottom, top, id;
    container(int id, int bottom, int top): top(top), bottom(bottom),id(id){
    }
};


struct Data {
    int ind;
    ll time;
    Data(int ind,ll time): ind(ind),time(time){}
    bool operator<(const Data& a) const {
    return time > a.time;
    }
};




void solve(){
    int n;
    cin >> n;
    
    string s;
    cin >> s;
    
    n = s.size();
    
    
    
    int cnt = 0;
    string cur;
    
    for(int i = 0; i < n; i++){
        cur += s[i];
        while (cur.size()>=3 && cur.substr(cur.size()-3) == "fox"){
            cur.pop_back();
            cur.pop_back();
            cur.pop_back();
            cnt++;
        }
    }
    
    
    
    cout << n-cnt*3;
}





int main() {
    int T = 1;
    //cin >> T;
    
    while (T--){
        solve();
    }
}





 