#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define pb push_back
#define FIFO ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define MOD 1000000007
#define mods 1000000009
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vii;
typedef vector<pll> vll;
int TestMillerRabin[9] = {2,3,5,7,11,13,17,19,23};
ll mulmod(ll a, ll b, ll p){
	ll x = 0, y = a%p;
	while(b>0){
		if(b%2==1) x = (x+y)%p;
		y = (1LL*y*2)%p;
		b = b/2;
	}
	return x%p;
}
ll fastexp(ll x, ll y, ll p){
	ll ans = 1;
	while(y > 0){
		if(y&1) ans = (1LL*ans*x)%p;
		y = y>>1;
		x = (1LL*x*x)%p;
	}
	return ans%p;
}
ll fastexpp(ll x, ll y, ll p){
	ll ans = 1;
	while(y > 0){
		if(y&1) ans = mulmod(ans,x,p);
		y = y>>1;
		x = mulmod(x,x,p);
	}
	return ans%p;
}
ll invmod(ll x, ll p){
	return fastexp(x,p-2,p)%p;
}
bool isPrime(ll p){
	bool flag = true;
	if(p<=1) return false;
	for(int i=0; i<9; i++){
		int value = TestMillerRabin[i];
		if(value >= p) break;
		if(fastexp(value,p,p) != value){
			flag = false;
			break;
		}
	}
	return flag;
}
vector <ll> prefhash(string p){
	int pi=31;
	vector <ll> pref;
	for(int i=0; i<p.size(); i++){
		if(i>0){
			ll aux = pref[i-1];
			pref.pb((aux+((p[i]-'a'+1)*fastexp(pi,i,mods))%mods)%mods);
		}
		else pref.pb(p[i]-'a'+1);
	}
	return pref;
}
ll hashsubs(string p, int i, int j, vector <ll> pp){
	int pi=31;
	int sz = j-i+1;
	ll fp = (pp[i+sz-1]-pp[i-1]+mods)%mods;
	ll sp = invmod(fastexp(pi,i,mods),mods);
	return (1LL*fp*sp)%mods;
}

int main(){
	int r,h;
	cin >> r >> h;
	int rest = h%r;
	ll answ = 2*(h/r);
	if(1LL*rest*rest*4 >= 3LL*r*r){
		answ+=3;
		cout << answ;
	}
	else{
		if(2LL*rest < r){
			answ+=1;
			cout << answ;
		}
		else{
			answ +=2;
			cout << answ;
		}
	}
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int h, r, ans;

int main(){
	cin >> r >> h;
	int t = h / (double(r) / 2);
	t = (t + 1) >> 1;
	ans = t << 1;
	double d = (ans - 1) * (double(r) / 2);
	d = h - d;
	if (d >= r * ((sqrt(3) - 1) / 2))
		++ans;
	cout << ans << '\n';
	return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main()
{ int r, h;
cin>>r>>h;
if (h-h/r*r<r and h-h/r*r>sqrt(3)*r/2) cout<<2*(h/r)+3;
else if (h-h/r*r>r/2) cout<<2*(h/r)+2;
else cout<<2*h/r+1;
return 0;
}

#include <cstdio>
#include <cmath>
const double eps = 1e-8;

int main()
{
    int r, h, ans;
    double d, cc;
    while(scanf("%d%d", &r, &h) != EOF)
    {
        ans = 2 * (h / r);
        d = h - h / r * r;
        cc = d - r * sqrt(3) * 0.5;
        if(fabs(cc) < eps || cc > 0)
            ans += 3;
        else if(2 * d >= r)
            ans += 2;
        else
            ans++;
        printf("%d\n", ans);
    }
    return 0;
}

#include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
#include<set>
#include<queue>
#include<deque>
#include<map>
#include<stack>
using namespace std;

int n, m, a, r = 0, s = 0;
vector<int> bikes;
vector<int> personals;
int ps[100000];

int main()
{
	int r, h;
    cin >> r >> h;
    int ans = h / r * 2;
    h = h % r;
    if (h * 2 < r)
    {
        ans++;
    }
    else
    {
    	if (h * 2 >= sqrt(3) * r)
    	{
        	ans += 3;
    	}
     	else
     	{
        	ans += 2;
    	}
    }
    cout << ans;
}

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <cmath>
#include <stack>
#include <queue>
#include <exception>
#include <numeric>
#include <algorithm>
#include <sstream>
#include <cstring>
#include <deque>
using namespace std;

typedef long long lo;
typedef vector< vector<lo> > vvl;
typedef vector< lo > vl;
typedef pair<lo, lo> ll;
typedef vector< pair<lo, lo> > vll;
typedef vector< vll > vvll;
typedef pair<lo, pair<lo, lo> > lll;
typedef pair<lo, lll > llll;
typedef vector<lll> vlll;
typedef vector<vvl> vvvl;
typedef vector<set<lo> > vs;
typedef map<lo, map<lo, lo> > mm;

#define N 1200100
#define LOGN 20

map<lo, pair<char, lo> >mp;
map<lo, pair<char, lo> >::iterator it;

lo r, h;

int main() {
	// ios_base::sync_with_stdio(false);
	// freopen("input.txt","r",stdin);e
	// freopen("output.txt","w",stdout);
	cin >> r >> h;
	lo d = (2*h + r) / (2*r);
	lo ans = 2*d;
	lo rhs = 2*h + r  - (2*d -1) * r,
		lhs = 3*r *r;
	rhs = rhs * rhs;
	ans  += (rhs >= lhs ? 1 : 0);
	cout << ans;
	return 0;
}

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <cmath>
#include <stack>
#include <queue>
#include <exception>
#include <numeric>
#include <algorithm>
#include <sstream>
#include <cstring>
#include <deque>
using namespace std;

typedef long long lo;
typedef vector< vector<lo> > vvl;
typedef vector< lo > vl;
typedef pair<lo, lo> ll;
typedef vector< pair<lo, lo> > vll;
typedef vector< vll > vvll;
typedef pair<lo, pair<lo, lo> > lll;
typedef pair<lo, lll > llll;
typedef vector<lll> vlll;
typedef vector<vvl> vvvl;
typedef vector<set<lo> > vs;
typedef map<lo, map<lo, lo> > mm;

#define N 1200100
#define LOGN 20

map<lo, pair<char, lo> >mp;
map<lo, pair<char, lo> >::iterator it;

lo r, h;

int main() {
	// ios_base::sync_with_stdio(false);
	// freopen("input.txt","r",stdin);
	// freopen("output.txt","w",stdout);
	cin >> r >> h;
	lo d = (2*h + r) / (2*r);
	lo ans = 2*d;
	lo rhs = 2*h + r  - (2*d -1) * r,
		lhs = 3*r *r;
	rhs = rhs * rhs;
	ans  += (rhs >= lhs ? 1 : 0);
	cout << ans;
	return 0;
}

#include<bits/stdc++.h>
#define ll long long
#define ld long double
#define M_PI (2*acos(0))
#define MAX_N 100001
using namespace std;

int main(){

    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    ll r,h;
    cin>>r>>h;

    ld hld = (ld)(h);
    ll fp = h/r;
    //full pairs

    hld = hld - (ld)(fp*r);
    ld left = (ld)(r) + (ld)(hld);
    ld x = sqrtl( (3.0/4.0) * r * r );
    if((ld)(hld)>=(ld)(r)/2.0){
        fp++;
        left = left - (ld)((ld)(r)/2.0);
        if( (left>=r) && ( left >= x + ( (ld)(r) / 2.0 ) ) ){
            cout<<1 + fp*2<<endl;
            return 0;
        }
        cout<<fp*2<<endl;
        return 0;
    }

    if( r + ( (hld+(ld)(r)/(2.0)) - x ) >= 3 * ( (ld)(r) / 2.0 ) ){
        fp++;
        cout<<fp*2<<endl;
        return 0;
    }

    cout<<(fp*2) + 1<<endl;

}

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <cmath>
using namespace std;

#define maxn 10101
#define maxe 202020

#define LL long long
LL a,b;
int main()
{
    while(scanf("%I64d %I64d",&a,&b)!=EOF)
    {
        if(a>b)
        {
            if(4*b*b<3*a*a)
			{
				if(a>2*b)
					puts("1");
				else puts("2");
			}
			else puts("3");
        }
        else
        {
            int k=b/a;
            int ans=k*2;
            LL m=b%a;
            if(3*a*a>4*m*m)
			{
				if(a>2*m)
					printf("%d\n",ans+1);
				else
					printf("%d\n",ans+2);
			}
			else printf("%d\n",ans+3);
        }
    }
}

#include <bits/stdc++.h>
#include <time.h>
#define ll long long
#define dub double
#define pii pair<int,int>
#define F first
#define S second
#define pb push_back
#define g1(x) scanf("%d", &x)
#define g2(x, y) scanf("%d%d", &x, &y)
#define g3(x, y, z) scanf("%d%d%d", &x, &y, &z)
#define gg1(x) scanf("%I64d", &x)
#define gg2(x, y) scanf("%I64d%I64d", &x, &y)
#define gg3(x, y, z) scanf("%I64d%I64d%I64d", &x, &y, &z)
#define p1(x) printf("%d\n", x)
#define p2(x) printf("%d %d\n", x, y)
#define cii(s) cin >> s
#define all(v) v.begin(), v.end()
#define NMAX1 1007
#define NMAX2 107
#define MOD 1000000007
#define INF NMAX1 * NMAX1 * NMAX2
#define SZ 700
#define FF ios_base::sync_with_stdio(0)

using namespace std;

int main()
{
    int r, h;
    g2(r, h);
    int sigurno = (h / r) * 2;
    int dole = h % r;
    if(dole >= 1.0 * r / 2.0 * sqrt(3.0)) sigurno += 3;
    else if(dole >= 1.0 * r / 2.0) sigurno += 2;
    else sigurno += 1;
    p1(sigurno);
    return 0;
}

#include <bits/stdc++.h>

#define FOR(i,a,b) for(int i=(a),_b=(b); i<=_b; i++)
#define FORD(i,a,b) for(int i=(a),_b=(b); i>=_b; i--)
#define REP(i,a) for(int i=0,_a=(a); i<_a; i++)
#define EACH(it,a) for(__typeof(a.begin()) it = a.begin(); it != a.end(); ++it)

#define DEBUG(x) { cout << #x << " = "; cout << (x) << endl; }
#define PR(a,n) { cout << #a << " = "; FOR(_,1,n) cout << a[_] << ' '; cout << endl; }
#define PR0(a,n) { cout << #a << " = "; REP(_,n) cout << a[_] << ' '; cout << endl; }

#define sqr(x) ((x) * (x))
using namespace std;

int main() {
    long long r, h;
    while (cin >> r >> h) {
        double margin = sqrt(r*r - r*r / 4.0) - r / 2.0;
        int can = (h / r) * 2;
        double last = (h / r) * r - r / 2.0;
        if (last + r + margin <= h) can += 3;
        else if (last + r <= h) can += 2;
        else ++can;

        cout << can << endl;
    }
    return 0;
}

//#pragma GCC optimize ('O3')
#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<ll,ll> pll;
typedef long double ld;
#define mp make_pair
#define f first
#define s second
#define pb push_back

const int N = 1e6 + 5;
const int M = 100 + 5;
const int OO = 1e9;
const int mod = 1e9 + 7;

// Geometry

typedef complex<double> point;
typedef pair<point, double> circle;
#define dot(a, b) ((conj(a)*(b)).real())
#define cross(a, b) ((conj(a)*(b)).imag())
#define lenSqr(a) (dot(a, a))
#define X real()
#define Y imag()
#define length(a) (hypot((a).X, (a).Y))
#define same(a, b) (lenSqr(vec(a, b)) < EPS)
#define vec(a, b) ((b)-(a))
#define normalize(a) ((a) / length(a))
#define EPS 1e-8
#define polar(r, ang) ((r)*exp(point(0, (ang))))
#define rotate(v, ang) (polar(v, ang))
const ld L_PI = acos(-1.0L);
const double PI = acos(-1);

int dcmp(double a, double b) {

    if(a-b > EPS) return 1;
    if(b-a > EPS) return -1;
    return 0;

}

double fixedAngle(double angle) {

    return dcmp(angle, 1) == 0 ? 1 : (dcmp(angle, -1) == 0 ? -1 : angle);

}

point getIntersection(point a, point b, point c, point d) {

    // Assuming both vectors are not parallel

    point u = vec(a, b);
    point w = vec(c, a);
    point v = vec(c, d);

    double t1 = - cross(w, v) / cross(u, v);
    return a + u * t1;

}

circle circleFrom3Points(point a, point b, point c) {

    point u = normalize(vec(a, b));
    point pu = {u.Y, -u.X};
    point m1 = (a + b) / 2.0;
    point v = normalize(vec(a, c));
    point pv = {v.Y, -v.X};
    point m2 = (a + c) / 2.0;
    point e1 = m1 + pu;
    point e2 = m2 + pv;
    point cen = getIntersection(m1, e1, m2, e2);
    double r = length(vec(cen, a));
    return {cen, r};

}

int h,r;

void init() {

}

int main() {

    ios_base::sync_with_stdio(false);
    cin.tie(0);

#ifndef ONLINE_JUDGE
    freopen("input.txt","r",stdin);
#else
#endif

    cin >> r >> h;

    // ...

    cout << 2 * (h / r) + (~dcmp(h % r, sqrt(3) * r / 2) ? 3 : (~dcmp(h % r, r / 2.0) ? 2 : 1));

    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

int main(){
    double r,h;
    scanf("%lf %lf", &r, &h);
    cout << (int)floor((h+r-floor((h+0.5*r)/r)*r)*2/sqrt((double)3)/r)+(int)floor((h+0.5*r)/r)*2<<endl;
    return 0;
}

// Template begins
// License:
// parth1211
#include<bits/stdc++.h>
using namespace std;
#define fio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define ll long long
#define endl "\n"
#define lb lower_bound
#define ub upper_bound
#define fo(i,a,b) for(i=a;i<=b;i++)
#define all(v) (v).begin()+1,(v).end()
#define sort0(v) sort(all(v))
#define lbb(a,b,arr,x) lower_bound(arr+a,arr+b+1,x)-arr
#define ubb(a,b,arr,x) upper_bound(arr+a,arr+b+1,x)-arr
#define freq(a,b,arr,x) upper_bound(arr+a,arr+b+1,x)-lower_bound(arr+a,arr+b+1,x)
typedef pair<ll,ll> pii;
typedef pair<ll,ll> pll;
#define d0(x) cout<<(x)<<" "
#define d1(x) cout<<(x)<<endl
#define d2(x,y) cout<<(x)<<" "<<(y)<<endl
#define d3(x,y,z) cout<<(x)<<" "<<(y)<<" "<<(z)<<endl
#define d4(a,b,c,d) cout<<(a)<<" "<<(b)<<" "<<(c)<<" "<<(d)<<endl
#define d5(a,b,c,d,e) cout<<(a)<<" "<<(b)<<" "<<(c)<<" "<<(d)<<" "<<(e)<<endl
#define d6(a,b,c,d,e,f) cout<<(a)<<" "<<(b)<<" "<<(c)<<" "<<(d)<<" "<<(e)<<" "<<(f)<<endl
#define max3(a,b,c) max(max((a),(b),(c)))
#define max4(a,b,c,d) max(max((a),(b)),max((c),(d)))
#define ss second
#define ff first
#define pb push_back
#define mp make_pair
template<class T> ostream& operator<<(ostream &os, vector<T> V) {
    for(auto v : V) os << v << " ";
    return cout << "";
}
template<class T> ostream& operator<<(ostream &os, set<T> S){
    for(auto s:S) os<<s<<" ";
    return cout << "";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {
    return os << P.first << " " << P.second;
}
// Template ends
const ll mod=998244353;

#define inf 9999999999999

ll inv(ll i){if(i==1) return 1;
return (mod-(mod/i)*inv(mod%i)%mod)%mod;}

ll gcd( ll a, ll b){if(a==0) return b;
return gcd (b,b%a);}

int main() {
  fio;
  ll i,j,m,f,f1,f2,t,a,b,k,d,n,r,h;
  //cin>>t;
  t=1;
  while(t--){
    cin>>r>>h;
    ll ans=2*(h/r);
    if((double)(h-r*(ans/2))/(double)r>=sqrt(3)/2){
      ans+=3;
      cout<<ans;
      return 0;
    }
    if(2*(h-(ans/2)*r)>=r){
      ans+=2;
      cout<<ans;
      return 0;
    }
    cout<<++ans;
  }
}

#include<bits/stdc++.h>

using namespace std;
typedef long double ld;
typedef long long ll;
const ld pi = acos(-1.0L);
const ld eps = 1e-9;
int main(){
	ios::sync_with_stdio(0); cin.tie(0);
	ll r, h; cin >> r >> h;
	r *= 2LL; h *= 2LL;
	ll ans = 2LL * (ll)(h / r);
	ll altura = h - (ans >> 1LL) * r;
	if (altura >= (r >> 1LL)){
		ans += 2LL;

		//todavia puede haber uno mas
		if (altura * altura + (r >> 1LL) * (r >> 1LL) >= r * r){
			ans ++;
		}
	}
	else{
		ans += 1LL;
	}
	cout << ans << "\n";
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

#define reps(i, s, n) for(int i=s; i<n; i++)
#define rep(i, n) reps(i, 0, n)
#define dreps(i, s, n) for(int i=n-1; i>=s; i--)
#define drep(i, n) dreps(i, 0, n)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define foreach(v, c) for(__typeof((c).begin()) v=(c).begin();v!=(c).end(); ++v)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define in(a,b) ((b).find(a) != (b).end())
#define cpresent(c,x) (find(all(c),x) != (c).end())
#define X real()
#define Y imag()
#define length(V) (hypot((V).X, (V).Y))

typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
typedef long long ll;
typedef long double ld;
typedef complex<double> point;
typedef pair<point, point> segment;
typedef pair<double, point> circle;
typedef vector<point> polygon;

const double PI = 2 * acos(0.0);
const double eps = 1e-9;

double r, h;

int main() {
   cin >> r >> h;
   int ans = 0;
   double half = floor(h / r);
   ans += half * 2;
   h = h - half * r;
   if (h * 2 < r) ans ++;
   else if (h * 2 >= r * sqrt(3)) ans += 3;
   else ans += 2;
   cout << ans << endl;
   return 0;
}

#include <iostream>
using namespace std;
double R,H;
int main()
{
    cin>>R>>H;
    double mod=(double)((int)H%(int)R);
    int add=0;
    if(R/2<=mod)
        add=2;
    if(0.86*R<=mod)
        add=3;
    if(R/2>mod)
        add=1;
    cout<<2*(int)(H/R)+add<<"\n";
    return 0;
}

#include<bits/stdc++.h>
#define int long long
using namespace std;
signed main()
{
    int r,h;
    scanf("%lld%lld",&r,&h);
    int ans=2*(h/r);
    h%=r;
    if(h*2>=r)
    {
        ans+=2;
        h-=r;
    }
    if((h+r)*(h+r)*4>=r*r*3) ans++;
    printf("%lld\n",ans);
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

// io
#define get(i) scanf("%d", &i)
#define flush fflush(stdin)

// manipulations
#define f(i, n) for (int i = 0; i < n; i++)
#define fr(i, n) for (int i = n - 1; i >= 0; i--)
#define ff(i, a, b) for (int i = a; i <= b; i++)
#define sz(x) int((x).size())
#define fi first
#define se second

// built-in
#define bitcount __builtin_popcount
#define gcd __gcd

// short
#define pb push_back
#define fill(arr, a) memset(arr, a, sizeof(arr))
#define mp(a,b) make_pair(a,b)

// useful bits
#define IN(i,l,r) (i >= l && i <= r);
#define relax(a,b) a = max(a,b);
#define relaxi(a,b) a = min(a,b);

typedef vector<int> VI;
typedef pair<int, int> PII;
typedef long long ll;
typedef long double ld;

ll modpow(ll a, ll b, ll mod = (ll) (1e9 + 7))
{if (!b) return 1; a %= mod; return modpow(a * a % mod, b / 2, mod) * (b & 1 ? a : 1) % mod;}

// for rand
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// use uniform_int_distribution<int>(0, i)(rng)

const double var = 0.86602540378;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);

	#ifndef ONLINE_JUDGE
//	freopen("output.txt", "w" , stdout);
	freopen("in.txt" , "r" , stdin);
	clock_t start = clock();
	#endif

	int r, h ,ans = 0;
	cin >> r >> h;
	ans = (h/r)*2;
	/* cerr << ans << endl; */
	h %= r;
	/* cerr << h << endl; */
	double d = var*r;
	double t = 0.5*r;
	if(h < t)
		ans++;
	else if( h < d )
		ans+=2;
	else
		ans += 3;
	cout << ans << endl;
	#ifndef ONLINE_JUDGE
	cout << setprecision(12) << ld(clock()-start) / CLOCKS_PER_SEC << endl;
	#endif
	return 0;
}

#include<bits/stdc++.h>
#define ll long long
#define ld long double
#define OO 1e18
#define oo 2e9
#define yalla ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define FILES freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
#define sz  100005
#define re return
#define F first
#define S second
#define pll pair<ll,ll>
#define mod  1000000007
#define pi acos(-1)
#define eps 1e-12
#define vec(a, b) (b - a)
#define pnt complex<ld>

/// a,b two vectors
#define dot1(a,b) 1.0*(conj(a)*b).real()
#define dot2(a,b) abs(a)*abs(b)*cos(arg(a)-arg(b))
#define cross(a,b) ((conj(a)*(b)).imag())
#define rule1(a,b) 1.0*dot1(a,b)/(1.0*abs(a)*abs(b))
#define angele_two_vec(a,b) acos( rule1(a,b) )*180.0/pi
#define angle_withXaxis(a) atan2((a).imag(),(a).real())
#define rotateO(p, ang) p * exp(pnt(0 , ang))
#define  length(a) (hypot((a).imag(), (a).real()))
///about==center
#define rotateA(p, ang, about)  rotateO(vec(about, p), ang) + about
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int,null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
template<class T> using ordered_class_set = tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
ll r,h,ans;
int main()
{
    yalla;
     cin>>r>>h;ans=0;
     ll rim=h%r;
     ans+=(2*(h/r));
     if(rim*2>=r)
     {ans+=2;
       ld d = sqrt(1.0 * rim *rim + 1.0 * r * r / 4);
       if(d >= r) ++ans;
     }
     else ans++;
     cout<<ans<<endl;
}

#include <bits/stdc++.h>
using namespace std;
#define ld double
#define ll long long
#define pb push_back
#define F first
#define S second
#define X real()
#define Y imag()
#define EPS 1e-6
#define pi acos(-1)
#define vec(a,b) (b)-(a)
#define ec_norm(a) (a).X*(a).X+(a).Y*(a).Y
#define norm(a) hypot((a).X,(a).Y)
#define angle(a) atan2((a).Y,(a).X)
#define dot(a,b) (conj(a)*(b)).X
#define cross(a,b) (conj(a)*(b)).Y
#define rotate(a,b,ang) ((b)-(a))*exp(point(0,(ang)))+(a)
#define reflect(p,a,b) conj(((p)-(a))/((b)-(a)))*((b)-(a))+(a)
typedef complex<ld> point;
typedef vector<point> polygon;
const int A = 5e5 + 2;
const int mod = 1e9 + 7;

int main() {
    ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    int r, h;
    cin >> r >> h;
    int ans = h / r * 2, rem = h % r;
    if (rem * 2 >= r) {
        ans++;
        ld r2 = r / 2.0;
        point c1(0, r2);
        point c2(r2, -rem + r2);
        ld d = norm(vec(c1, c2));
        if (d + EPS >= r)
            ans++;
    }
    cout << ans + 1;
    return 0;
}

#include <iostream>
#include <algorithm>
using namespace std;

int r, h;

int main()
{
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif

    cin >> r >> h;

    int ans = 0;
    int pos = 0;

    while (2 * pos + r <= 2 * h)
    {
        ans += 2;
        pos += r;
    }

    if (4LL * (h + r - pos) * (h + r - pos) >= 3LL * r * r)
        ans++;

    cout << ans;

    return 0;
}

#include<bits/stdc++.h>
#define int long long int
#define pb push_back
#define endl "\n"
#define F first
#define S second
#define mod 1000000007
using namespace std;

main()
{
    ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    int r, h;
    cin >> r >> h;
    int ans = (h / r) * 2;
    h %= r;
    if(2 * h < r){
        ans++;
    }
    else if(2 * h >= sqrt(3) * r)
        ans += 3;
    else ans += 2;
    cout << ans << endl;
}

#include<bits/stdc++.h>
using namespace std;
int r,h;
int main() {
	scanf("%d%d",&r,&h);
	int ans=(h/r)*2;
	int k=h%r;
	if (k>=(double)r/2) {
		ans+=2;
		if (k+r>=(double)r*(1+sqrt(3)/2)) ans++;
	}
	else ans++;
	printf("%d",ans);
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
	ll r , h ;
	cin >> r >> h ;
	ll res = 0 ;
	res += 2*(h/r);
	ll d = h%r ;
	if( 0<=d && d< (r+1)/2 ){
		res++;
	}
	else if( (r+1)/2<=d && d<= (ll)floor(r*sqrt(3)/2.0) ){
		res+=2;
	}
	else res+=3;
	cout<<res<<endl;

	return 0;
}

#include <cstdio>

typedef long long LL;

int _r, _h;
LL r, h;

int main() {
    scanf("%d %d", &_r, &_h);

    h =_h*2;
    r =_r*2;

    int halves = h/(r/2);

    int res;

    if(halves == 0) res = 1;
    else {
        int circles = (halves+1)/2;
        res = 2*circles;

        LL z = h+r -  (2*circles-1)*(r/2) - r/2;
        if(r*r - (r/2)*(r/2) <= z*z) res++;

    }
    printf("%d\n", res);

}

#include<cstdio>

typedef long long int64;
int r,h,left,answer;
#define SQR(X) (((int64)(X))*(X))

int main() {
    scanf("%d%d",&r,&h);
    answer=(h+r/2)/r*2;
    if(SQR((h+r)-(h+r/2)/r*r)*4>=SQR(r)*3) {
        answer++;
    }
    printf("%d\n",answer);
    return 0;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <cstring>
#include <queue>
#include <deque>
#include <functional>
#include <climits>
#include <cassert>
#include <list>

#define mp make_pair
#define mt(a, b, c) mp(a, mp(b, c))
#define ABS(a) (((a) > 0) ? (a) : (-(a)))
#define ZERO(x) memset((x), 0, sizeof(x))
#define NEGATE(x) memset((x), 255, sizeof(x))

using namespace std;
typedef long long ll;

int main()
{
#ifdef XXX
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif

	int r, h;
	cin >> r >> h;

	int ans = 0;

	int res = 0;

	for (double u = r / 2.0; u <= h + 1e-9; u += r)
		res++;

	ans = res * 2;

	double x = (r + sqrt(3.0) * r) / 2.0;

	res = 1;

	for (double u = x; u <= h + r + 1e-9 - r / 2.0; u += r)
		res += 2;

	cout << max(res, ans);

	return 0;
}

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;

int main() {
	int r,h;
	scanf("%d%d",&r,&h);
	int ans=h/r*2;
	h=h%r;
	if(h*2<r) {
		ans++;
	} else if(h*2<sqrt(3)*r) {
		ans+=2;
	} else {
		ans+=3;
	}
	printf("%d",ans);
	return 0;
}

#include <list>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <climits>
#include <cfloat>
#include <numeric>
#include <iomanip>
#include <cassert>
#include <unordered_map>
#include <unordered_set>
#include <tuple>
using namespace std;

typedef long long ll;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;

const int oo = 0x3f3f3f3f;
const double eps = 1e-9;

#define sz(c) int((c).size())
#define all(c) (c).begin(), (c).end()
#define FOR(i,a,b) for (int i = (a); i < (b); i++)
#define FORD(i,a,b) for (int i = int(b)-1; i >= (a); i--)
#define FORIT(i,c) for(__typeof__((c).begin()) i=(c).begin(); i!=(c).end(); i++)
#define mp make_pair
#define pb push_back
#define DBG(...) { if(1) fprintf(stderr, __VA_ARGS__); }
#define DBGDO(X) { if(1) cerr << "DBGDO: " << (#X) << " = " << (X) << endl; }

int main() {
	ll R, H;
	cin >> R >> H;
	ll res = (2*H + R) / R;
	res &= ~1;
	if (double(res / 2 * R) + sqrt(double(R*R) * 3 / 4) < H+R+eps)
		res++;
	cout << res << endl;
}

//13:49
#include<iostream>
#include<cstdio>
#include<cmath>

using namespace std;

int main()
{
	int r,h;
	scanf("%d%d",&r,&h);
	int ans=h/r*2;
	h%=r;
	if(1.0*h>=1.0*r*sqrt(3)*0.5) ans+=3;
	else if(h>=r/2+(r%2)) ans+=2;
	else ans+=1;
	printf("%d\n",ans);
	return 0;
}

#include <iostream>
#include <cmath>
#include <cstdio>
#include <algorithm>

using namespace std;

int r, h;

int main()
{
    scanf("%d%d", &r, &h);
    int ans = h / r;
    int rem = h % r;
    ans <<= 1;
    ++ans;
    if(2 * rem >= r)    ++ans;
    if(2* rem >= sqrt(3.0) * r) ++ans;
    printf("%d\n", ans);
    return 0;
}

#include <bits/stdc++.h>
#define  ll  long long
#define  pii pair<int,int>
#define  pll pair<ll , ll>
#define  debug cout << "this far" << endl;
#define  For(i, n) for(int i = 0; i < (n); ++i)
#define  lsb(x) ((x) & (-x))
#define  PI acos(-1)
#define  line cout << endl;
#define  getbit(n, i) (((n) & (1LL << (i))) != 0)
#define  resetbit(n, i) ((n) & (~(1LL << (i))))
#define  setbit(n, i) ((n) | (1LL << (i)))
#define  togglebit(n, i) ((n) ^ (1LL << (i)))
#define  gap " "
using namespace std;
const int N = 5e5 + 10;
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    setprecision(20);
    int r, h;
    cin >> r >> h;
    ll ans = 2 * (h / r);
    double rem = h % r;
    int x1 = 1, x2 = 0, x3 = 0;
    double R = (double)(r) / 2;
    if (rem >= R) x2 = 2;
    double tmp = sqrt(3) * R + R + R;
    if (rem + r >= tmp) x3 = 3;
   // cout << tmp << endl;
  //  cout << rem + r << endl;
    cout << ans + max(x1, max(x2, x3));

}

#include <bits/stdc++.h>
using namespace std;

int h, r;

const double pi = acos(-1);

int main() {
	scanf("%d %d", &r, &h);
	int a = ((2 * h + r) / (2 * r)) * 2;
	double x = 1.0 * r * sin(pi / 3);
	double hhh = h + r - x;
	int hh = hhh;
	int b = 1 + 2 * (hh / r);
	printf("%d\n", max(a, b));
	return 0;
}

#include <iostream>
#include <cmath>

using namespace std;

const double sin60 = sqrt(3.0)/2;

int main(){
    int h, r;
    cin >> r >> h;

    if(h < r/2.0){
        cout << 1;
    }else if(h >= r/2.0 && h < sin60 *r){
        cout << 2;
    }else{
        int t = (h - sin60 * r) / r;
        int s = 2 * t + 3;
        if(h >= 1.5*r + t * r){
            s += 1;
        }
        cout << s;
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define forr(i, a, b) for(int i = (a); i < (int) (b); i++)
#define forn(i, n) forr(i, 0, n)
#define forall(it, v) for(auto it = v.begin(); it != v.end(); ++it)
#define dforn(i, n) for(int i = ((int) n) - 1; i >= 0; i--)
#define db(v) cerr << #v << " = " << v << endl
#define pb push_back
typedef long long ll;
const int MAXN = -1;

ll F, S;
ll cuenta(ll x, ll y, ll r, bool slim){
    ll L = y/(sqrt(3)*r) + (sqrt(3)-2)/sqrt(3);
    return (L/2) * (F + S) + ((L%2 && !slim) ? F : 0);
}
ll contame(ll x, ll y, ll r, bool slim){
    F = x / (2*r); S = (x - r) / (2*r);
    ll acum = 0, ans = 1;
    while((double)y >= (slim ? (2+sqrt(3))*r : 0)){
        ans = max(ans, cuenta(x, y, r, slim) + acum);
        acum += F;
        y -= 2*r;
    }
    return ans;
}

ll h, r, ans;

int main(){
	while(cin >> r >> h){
	    h *= 2;
	    printf("%lld\n", max(contame(4*r, h + r, r, 0), contame(4*r, h + 2*r, r, 1)));
	}
	return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define forr(i, a, b) for(int i = (a); i < (int) (b); i++)
#define forn(i, n) forr(i, 0, n)
#define forall(it, v) for(auto it = v.begin(); it != v.end(); ++it)
#define dforn(i, n) for(int i = ((int) n) - 1; i >= 0; i--)
#define db(v) cerr << #v << " = " << v << endl
#define pb push_back
typedef long long ll;
const int MAXN = -1;

ll F, S;
ll cuenta(ll x, ll y, ll r, bool slim){
    ll L = (double)(y - 2*r)/ (sqrt(3)*r) + 1;
    return (L/2) * (F + S) + ((L%2 && !slim) ? F : 0);
}
ll contame(ll x, ll y, ll r, bool slim){
    F = x / (2*r); S = (x - r) / (2*r);
    ll acum = 0, ans = 1;

    while((slim && (y*y - 4*r*y + r*r >= 0)) || (!slim && y >= 0)){
        //printf("Comiendo %lld en lineas paralelas contamos %lld extra.\n", acum, cuenta(x, y, r, slim));
        ans = max(ans, cuenta(x, y, r, slim) + acum);
        acum += F;
        y -= 2*r;
    }
    return ans;
}

ll h, r, ans;

int main(){
	while(cin >> r >> h){
	    h *= 2;
	    printf("%lld\n", max(contame(4*r, h + r, r, 0), contame(4*r, h + 2*r, r, 1)));
	}
	return 0;
}

#include <iostream>
#include <cstdio>
#include<list>
#include<iomanip>
#include<cmath>
#include <random>
#include<queue>
#include <functional>
#include<stdio.h>
#include<assert.h>
#include<stack>
#include <unordered_map>
#include<sstream>
#include <cstdlib>
#include<map>
#include<algorithm>
#include<iostream>
#include<set>
#include<utility>
#include<memory.h>
#include<string>
#include<vector>
#include<numeric>
using namespace std;
#define ios std::ios_base::sync_with_stdio(false);
#define ll  long long
#define pb push_back
#define fi(ss) freopen (ss,"r",stdin)
#define fo(ss) freopen (ss,"w",stdout)
#define sz(v)               ((int)((v).size()))
#define all(x)          (x).begin(),(x).end()
#define REP(i, v)       for(int i=0;i<sz(v);i++)
#define lp(i,n) for(int i = 0 ; i < n ; ++i)
#define hash ___hash
#define next ___next
#define prev ___prev
#define left ___left
typedef pair<ll,ll> pii;
#define F first
#define S second
#define MP make_pair
double pi = acos(-1.0);

int main() {
	ll r,h;
	cin >> r >> h;
	ll p = 2*(h/r);
	ll rem = h % r;
	double x = sqrt(1.0*r*r -(r/2.0)*(r/2.0));
	//cout << x << "\n";
	if(x - r <= rem && x < rem)
	{
		p += 3;
	} else {
		 if(2LL* rem >= r) {

			 p += 2;
		 }
		else ++p;
	}
	cout << p << "\n";

}

#include <bits/stdc++.h>
using namespace std;
#define read() freopen("input.txt", "r", stdin)
#define write() freopen("output.txt", "w", stdout)
#define ff(i,a,b) for(int i = (a); i <= (b); i++)
#define fr(i,a,b) for(int i = (a); i >= (b); i--)
#define REP( i , n ) for( int i = 0 ; i < n ; i++ )
#define REPI( n , i ) for( int i = n ; i >= 0 ; i-- )
#define sc( x ) scanf( "%d" , &x )
#define sc2( x , y ) scanf( "%d%d" , &x , &y )
#define scd( x ) scanf( "%.9f" , &x )
#define scl( x ) scanf( "%I64d" , &x )
#define pf( x ) printf( "%d\n" , x )
#define pfd( x ) printf( "%.9f\n" , x )
#define pfl( x ) printf( "%I64d\n" , x )
#define rrc( x ) return cout << x , 0 ;
#define all( v ) v.begin(),v.end()
#define all_r( v ) v.rbegin() , v.rend()
#define fi first
#define se second
#define endl '\n'
#define SZ(a) int(a.size())
#define pb push_back
#define cln( x , v ) memset( x , v , sizeof( x ) )
#define pi acos(-1.0)
#define e2( x ) ( 1LL*( x )*( x ) )
#define r2( x ) sqrt( 1.0*( x ) )
#define ones(x) __builtin_popcount(x)
#define MCM( a , b ) ( ( a*b )/( __gcd( a , b ) ) )
#define ddd cout << "despues" << endl ;
#define sss cout << "------------------" << endl ;
#define aaa cout << "antes" << endl ;
#define da( a , b ) ( (a)/(b) - ( (a) < 0 && (a)%(b) != 0 ) )
#define ceil_( a , b ) ( da( (a) , (b) ) + ((a)%(b) > 0) )
#define Mm greater<int>
#define nxtPerm next_permutation

typedef double db ;
typedef long double ld ;
typedef long long ll ;
typedef vector<int> vi ;
typedef vector<vi> vvi ;
typedef vector<ll> vl ;
typedef vector<bool> vb ;
typedef pair<int,int> pii ;
typedef vector<pii> vpii ;
const ld EPS = 1e-8 ;
const int INF = (int)( 1e8 ) ;
const ll mod = (int)( 1e+9 + 7 ) ;
const int N = (int)( 1e3 ) ;
int days_month[ 12 ] = { 31 , 28 , 31 , 30 , 31 , 30 , 31 , 31 , 30 , 31 , 30 , 31 };
//inline ll modulo( ll num ){ ( ( num %= mod ) += mod ) %= mod ; return num ; }
//inline ll pot( int b , int e ){ ll p = 1 ; REP( i , e ) p = (p*b)%mod ; return p ; }

int main()
{
//	ios_base::sync_with_stdio(0);
	ll r , h ;
	cin >> r >> h ;
	ll k = h / r ;
	h -= r * k ;
	k *= 2 ;
	k += 1 + ( h >= r/2.0 ) ;
	h = h + r - r2( 3 )*r/2.0 ;
	k += ( h >= r ) ;
	cout << k ;

	return 0 ;
}

#include <stdio.h>
#include <stdlib.h>

int main()
{
  /*freopen("input.txt", "w", stdout);
  printf("1000\n");
  for(int i = 1; i < 101; i++)
  {
    for(int j = 1; j < 101; j++)
    {
      printf("%d %d\n", i, j);
    }
  }
  return 0;*/
  int QWE = 1;
  #ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  //freopen("output.txt", "w", stdout);
  scanf("%d", &QWE);
  #endif
  for(int T = 0; T < QWE; T++)
  {
    double r, h;
    __int64 answer;
    //ReadData
    scanf("%lf %lf", &r, &h);
    //Solve
    answer = 0LL;
    double mh = h - r / 2.0;
    double top = 0.0;
    for(double i = r / 2.0; i <= h; i += r)
    {
      answer += 2;
      top += r;
    }
    top -= r / 2.0;
    double tmp = r *r + 4.0 * (h + r - top) * (h + r - top);
    if(r *r + 4.0 * (h + r - top) * (h + r - top) >= 8.0 *r * r)
      answer++;
    //WriteData
    //printf("r:%I64d h:%I64d %I64d\n", r, h, answer);
    printf("%I64d\n", answer);
  }
  return 0;
}

#include<iostream>
using namespace std;
int main(){
    int r,h;cin>>r>>h;int ans=2*(h/r)+1;int z=h%r;if (2*z>=r){ans++;}if (2*z>=r*1.7320508){ans++;}cout<<ans<<endl;
    return 0;
}

#if 1

#include <iostream>
#include <stdio.h>
#include <map>
#include <string>
#include <vector>
#include <stdlib.h>
#include <ctime>
#include <algorithm>
#include <cmath>
#include <queue>
#include <assert.h>
#include <set>
#include <stack>
#include <math.h>
#include <string.h>
#include <cstring>
#include <fstream>
#include <sstream>
#include <complex>

using namespace std;

typedef long double LD;
typedef long long LL;

#define pb push_back
#define mp make_pair
#define X first
#define Y second

const int inf = 1e9;
const LD eps = 1e-9;
const LD pi = acos(-1.0);

int xabs(int x) {return x < 0 ? -x : x;}

struct see
{
	int t, l, r;
	see() {}
	see(int t, int l, int r) :t(t), l(l), r(r) {}
};

int sign(int x)
{
	if (x == 0)
		return 0;
	return x < 0 ? -1 : 1;
}
int main()
{
	LL r, h;
	cin >> r >> h;
	h *= 2;
	r *= 2;

	LL cnt = 0;
	int c1 = (h + r / 2) / r;
	c1 *= 2;
	LL ost = (h + r / 2) % r;
	if ((ost + r / 2) * (ost + r /2) + (r / 2) * (r / 2) >= r * r)
		c1 += 1;
	cout << c1 << endl;
	return 0;
}

#endif

#if 0
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

#define N 100009

int data[7] = {0};
int t[N],l[N],r[N];

int main(void)
{
	int i,n,m,s,f;
	while(scanf("%d %d %d %d",&n,&m,&s,&f)==4)
	{
		for(i=1;i<=m;i++)
		{
			scanf("%d %d %d",&t[i],&l[i],&r[i]);
		}
		for(i=1;i<=m;i++)
		{
			if(s < l[i] || s > r[i])
			{
				if(s < f)
				{
					if((s+1)<l[i] || (s+1) > r[i])
					{
						s++;
						printf("R");
					}
					else
					{
						printf("X");
					}
				}
				else
				{
					if((s-1)<l[i] || (s-1) > r[i])
					{
						s--;
						printf("L");
					}
					else
					{
						printf("X");
					}
				}
				if(s == f)
				{
					break;
				}
			}
			else
			{
				printf("X");
			}
		}
		while(s < f)
		{
			s++;
			printf("R");
		}
		while(s > f)
		{
			s--;
			printf("L");
		}
		printf("\n");
	}

	return 0;
}

#endif

#if  1

#include<iostream>
#include<cmath>
using namespace std;

int main(void)
{
	int i;
	__int64 r, h;
	while(scanf("%I64d %I64d",&r,&h)==2)
	{
		if(h >= r)
		{
			__int64 k = h/r;
			__int64 ans = k*2;
			__int64 res = h%r;
			if(res >= 0.5*sqrt(3.0)*r)
				printf("%I64d\n",ans+3);
			else if(res >= 0.5*r)
				printf("%I64d\n",ans+2);
			else
				printf("%I64d\n",ans+1);
		}
		else
		{
			if(h >= 0.5*sqrt(3.0)*r)
				printf("3\n");
			else if(h>=0.5*r)
				printf("2\n");
			else
				printf("1\n");
		}
	}
	return 0;
}

#endif

#include<cstdio>
#include<string>
#include<cstring>
#include"string.h"
#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<iomanip>
#include<vector>
using namespace std;
#define eps 1e-8
int r,h;
__int64 ans=0;
double dcmp(double a){
	if(abs(a)<eps)return 0;
	else if(a>0)return 1;
	return -1;
}
int main(){
	while(scanf("%d %d",&r,&h)!=EOF){
		ans=(h/r)*2;
		double u=h%r;
		double r1=double(r)/2;
		double r2=double(r)/2*sqrt(3.0);
		if(dcmp(u-r2)>=0)ans+=3;
		else if(dcmp(u-r1)>=0)ans+=2;
		else ans+=1;
		printf("%I64d\n",ans);
	}
	return 0;
}

#include <stdio.h>
#include <math.h>

int main()
{
    int h, r;

    scanf("%d%d", &r, &h);

    int kol;

    if ( (double)h / r - h / r < 0.5 )
        kol = (h / r) * 2;
    else
        kol = (h / r + 1) * 2;

    double a = h + r - (kol / 2) * r;
    double b = r / 2;
    double c = sqrt( a * a + b * b );

    if (c >= (double)r)
        kol++;

    printf("%d",kol);

    return 0;
}

#include <iostream>

using namespace std;
const double eps = 1e-5;

int main()
{
	int r1, h;
	cin >> r1 >> h;
	int k = (h / r1) * 2;
	double d = h % r1;
	double r = r1;
	if (d - sqrt(3.) * r / 2 >= 0)
	{
		cout << k + 3;
		return 0;
	}
	if (d - r / 2 >= 0 )
	{
		cout << k + 2;
		return 0;
	}
	cout << k + 1;
	return 0;
}

#include <algorithm>
#include <numeric>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <iostream>
#include <iterator>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <sstream>
#include <utility>
#include <functional>
#include <bitset>

using namespace std;

typedef long long ll;
typedef vector<int> VI;
typedef vector<vector<int> > VVI;
typedef pair<int, int> pii;

#define FOR(i, x, y) for(ll i=x; i<=y; i++)
#define FORD(i, x, y) for (ll i = x; i >= y; --i)
#define REP(i, n) for(ll i=0; i<n; i++)
#define REPD(i, n) for(ll i = n - 1; i >= 0; --i)

#define ALL(c) (c).begin(), (c).end()
#define SORT(c) sort(ALL(c))
#define UNIQ(c) SORT(c),(c).resize(unique(ALL(c))-(c).begin())
#define SZ(c) (int)(c).size()

#define CLEAR(x) memset(x,0,sizeof x)
#define FILL(x, v) memset(x,v,sizeof x)
#define COPY(from, to) memcpy(to, from, sizeof to)

#define pb push_back
#define mp make_pair
#define X first
#define Y second

const double eps = 1.0e-7;
const double pi = acos(-1.0);

int main() {
    int r, h;
    cin >> r >> h;
    h *= 2, r *= 2;
    int res = (h + r / 2) / r;
    h = h - res * r + r;
    res *= 2;
    if (h * 1.0 >= r * sqrt(3.0) / 2.0) ++res;
    cout << res << endl;
    return 0;
}

#include<stdio.h>
#include<string.h>
#define gen3 1.7320508
int main()
{
   double h,r;
   scanf("%lf%lf",&r,&h);
   double di=(1.0-gen3/2)*r;
   if (h<r/2) {printf("1\n");return 0;}
   if ((h+di)<r) {printf("2\n"); return 0;}
   if (((h+di)/r)*2+1>((1.0*(h-r/2))/r)*2+2) printf("%d\n",(int)(((h+di)/r)*2+1));
   else printf("%d\n",(int)((h-r/2)/r)*2+2);
   return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define LL long long
#define LD long double
int main(){
	LD r,h;
	cin>>r>>h;
	LL l=(int)h%(int)r,n=((int)h/(int)r)*2+1;
	if (l>=r/2*sqrt(3)){
		n=n+2;
	}else if(l>=r/2){
		n=n+1;;
	}
	cout<<n;
	return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define re return
#define du double
int main(){
    float r,h;
    cin >> r >> h;
    ll ans1=2*(h*2+r)/(2*r);
    ll ans2=1+2*(int)((2*h+r*(2-sqrt(3)))/(2*r));
    cout << max(ans1,ans2);
    re 0;
}

#include <iostream>
#include <fstream>
#include <stdlib.h>
#include <algorithm>
#include <cmath>

using namespace std;

int h, r , ans;

int main(){
#if 1
    std::istream &in = std::cin;
#else
    std::ifstream in ("in.txt");
#endif
    in>>r>>h;
    while(h-r>=-r/2.0)
    {
        h-=r;
        ans++;
    }
    ans*=2;
    if((abs(h)<r*(1-sqrt(3.0)/2.0)) || h>=0)
        ans++;
    cout<<ans;
    return 0;
}

#include<stdio.h>
#include<iostream>
using namespace std;
int main()
{
    double r,h;
    int max=0;
    cin >> r >> h;
    max+=h/r;
    h=h-max*r;
    max*=2;
    if(4*h*h>=3*r*r)
        max+=3;
    else if(h>=r/2)
        max+=2;
    else
        max++;
    cout << max << endl;
    return 0;
}

//Saatwik Singh Nagpal
#include <bits/stdc++.h>
using namespace std;
int main()
{
	int h,r;
    cin>>r>>h;
    int ans=h/r;
    ans*=2;
    h%=r;
    if(h>=sqrt(3)*(double)r/(double)2)
        ans+=3;
    else if(h>=(double)r/(double)2)
        ans+=2;
    else
        ans++;
    cout<<ans<<endl;
    return 0;
}

// luogu-judger-enable-o2
#include<bits/stdc++.h>
#include<unordered_set>
#define rg register ll
#define inf 2147483647
#define min(a,b) (a<b?a:b)
#define max(a,b) (a>b?a:b)
#define ll long long
#define maxn 200005
const double eps = 1e-6;
using namespace std;
inline ll read()
{
	char ch = getchar(); ll s = 0, w = 1;
	while (ch < 48 || ch>57) { if (ch == '-')w = -1; ch = getchar(); }
	while (ch >= 48 && ch <= 57) { s = (s << 1) + (s << 3) + (ch ^ 48); ch = getchar(); }
	return s * w;
}
inline void write(ll x)
{
	if (x < 0)putchar('-'), x = -x;
	if (x > 9)write(x / 10);
	putchar(x % 10 + 48);
}
double r,h;
int main()
{
    cin>>r>>h;
    cout<<max((ll)(2+2*(h-r/2.0)/r),1+2*(ll)((h+r*(1-0.5*sqrt(3)))/r))<<endl;
    return 0;
}

/*
 * Author:  DreamHigh
 * Created Time:  2013/9/7 17:01:20
 * File Name: CF.cpp
 * solve: CF.cpp
 */
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<map>
#include<stack>
#include<set>
#include<iostream>
#include<vector>
#include<queue>
//ios_base::sync_with_stdio(false);
//#pragma comment(linker, "/STACK:1024000000,1024000000")

using namespace std;
#define sz(v) ((int)(v).size())
#define rep(i, a, b) for (int i = (a); i < (b); ++i)
#define repf(i, a, b) for (int i = (a); i <= (b); ++i)
#define repd(i, a, b) for (int i = (a); i >= (b); --i)
#define clr(x) memset(x,0,sizeof(x))
#define clrs( x , y ) memset(x,y,sizeof(x))
#define out(x) printf(#x" %d\n", x)
#define sqr(x) ((x) * (x))
typedef long long LL;

const int INF = 1000000000;
const double eps = 1e-10;
const int maxn = 30000;

int sgn(const double &x) {  return (x > eps) - (x < -eps); }

const double genhao3 = (double)sqrt(3);
int main()
{
    //freopen("in.txt","r",stdin);

    LL r,h;
    scanf("%I64d%I64d",&r,&h);

    LL num = h/r;
    LL l = h%r;

    num = 2*num;
    if(3*r*r <= 4*l*l)
    {
        num+=3;

    }else if(2*l >= r)
        num += 2;
    else
        num++;

    cout<<num<<endl;
    return 0;
}

/*************************************************************************
    > File Name: c.cpp
    > Author: Nature
    > Mail: 564374850@qq.com
    > Created Time: Tue 28 Oct 2014 11:12:26 PM CST
************************************************************************/

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <iostream>
#include <algorithm>
using namespace std;
#define lp (p << 1)
#define rp (p << 1|1)
#define getmid(l,r) (l + (r - l) / 2)
#define MP(a,b) make_pair(a,b)
typedef long long ll;
const int INF = 1 << 30;
const double the = sqrt(3.0);
const double eps = 1e-8;

double R,r,h;
int k,ans1 = 0,ans2 = 0,th;

int main(){
	cin >> R >> h;
	r = R / 2.0;
	double tmp = the * r / 2.0;
	double tmp1 = 2 * r - the * r;
	k = (int)((h + tmp1) / R);
	if(h + tmp1 - (k * R + tmp + r) > eps)
		ans1 = 1;
	ans1 += 2 * k + 1;

	k = (int)((h - r) / R);
	if(h - r - (k * R + tmp + r) > eps)
		ans2 = 1;
	if(h >= r)
	ans2 += 2 * k + 2;
	cout << max(ans1,ans2) << endl;
	return 0;
}

    #include <cstdio>
    #include <cstring>
    #include <cmath>
    #include <algorithm>

    #define M 100005
    #define eps 1e-8
    #define INF 0x7fffffff

    using namespace std;

    int main ()
    {
        int h, r;
        scanf("%d%d", &r, &h);
        int ans = h/r*2;
        double yy = h-h/r*r;
        if(yy>=sqrt(3.0)*0.5*r) ans += 3;
        else if(yy >= 0.5*r) ans+=2;
        else ans += 1;
        printf("%d\n",ans);
        return 0;
    }

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <cassert>
using namespace std;
#define SIZE(vn) vn.size()
const long long modulo = 1000000007;
#define SET0(zn) memset(zn,0,sizeof(zn))
#define SET(zn, k) memset(zn,k,sizeof(zn))
#define REP(i,n)  for (int i=0; i<(n); ++i)
typedef long long LL;
template <class T> void refreshMin(T & a, const T & b) {if (a>b) a = b;}
template <class T> void refreshMax(T & a, const T & b) {if (a<b) a = b;}

void main() {
	int h,r;
	cin>>r>>h;
	int t = r   + h * 2;
	int re = 0;
	re =   t /  (2*r) ;

	double  dis = h+r -  re * r + 0.5 * r;
	re*=2;
	if (dis >= ( sqrt(3.0) /2.0  + 0.5) * r ) re++;
	cout<<re;

}

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main(){
	long long r,h1,ans1=0,ans2=0;
	cin>>r>>h1;
	ans1+=(2*h1+r)/(2*r);
	ans1*=2;
	double h2,k=3;
	h2=h1-(sqrt(k)*r/2)+r;
	ans2+=h2/r;
	ans2*=2;
	ans2++;
	cout<<max(ans1,ans2);
}

#include <bits/stdc++.h>

using namespace std;

const double eps = 1e-12;

int main() {
  long long R, h;
  scanf("%I64d %I64d", &R, &h);
  long long ans = h / R * 2;
  long long H = h / R * R;
  if(2 * H <= 2 * h - R) {
    ans += 2;
    H += R;
  }
  double t = (double) R * sqrt(3) / 2;
  if(H + t - eps < h + R) {
    ans++;
  }
  cout << ans << endl;
  return 0;
}

#include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>

using namespace std;

int main() {
    long long r, h;
    cin >> r >> h;
    long long b = h / r;
    long long c = h % r;
    b*=2;
    if(c*c*4 >= r*r*3) {
        b+=3;
    } else if(c >= (r+1)/2) {
        b+=2;
    } else {
        b++;
    }
    cout<<b<<endl;
}

#include <bits/stdc++.h>
using namespace std;
int main() {
    long double r,h;
    cin >>r >> h;
    cout << max(1+2*(int)(h/r+1-1.73205/2),2*(int)((h+0.5*r)/r));
    return 0;
}

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<map>
#include<algorithm>
#include<queue>
#include<iomanip>
#include<unordered_map>
using namespace std;
#define MAXN 100100
#define eps 1e-7
#define For(i,a,b) for(int i=a;i<=b;i++)
#define Fore(i,a,b) for(int i=a;i>=b;i--)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define mkp make_pair
#define pb push_back
#define cr clear()
#define sz size()
#define met(a,b) memset(a,b,sizeof(a))
#define iossy ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define fre freopen
#define pi acos(-1.0)
#define inf 1e9+9
#define Vector Point
#define fir first
#define sec second
typedef pair<int,int> pii;
const int Mod=998244353;
typedef unsigned long long ull;
typedef long long ll;
int dcmp(double x) {
	if(fabs(x)<=eps) return 0;
	return x<0?-1:1;
}
struct Point {
	ll x,y;
	Point() {}
	Point(ll x,ll y):x(x),y(y) {}
	Point operator - (const Point &a)const { return Point(x-a.x,y-a.y); }
	Point operator + (const Point &a)const { return Point(x+a.x,y+a.y); }
	Point operator * (const double &a)const { return Point(x*a,y*a); }
	bool operator < (const Point &a)const { if(x==a.x) return y<a.y; return x<a.x; }
	bool operator == (const Point &a)const { return x==a.x && y==a.y; }
};
struct cycle{
	Point p;
	ll r;
	cycle(){}
	cycle(Point p,ll r) : p(p),r(r) {}
};
struct Line{
	Point p;
	Vector v;
	double ang;
	Line() {}
	Line(Point p,Vector v):p(p),v(v){ ang=atan2(v.y,v.x); }
	bool operator < (const Line &l)const { return ang<l.ang; }
};
ll Cross(Vector a,Vector b) { return a.x*b.y-a.y*b.x; }
ll Dot(Vector a,Vector b) { return a.x*b.x+a.y*b.y; }
double a,b;
void solve(){
	cin>>a>>b;
	int ans1=0,ans2=(int)((b-a/2)/a)*2;
	if(b*2>=a) ans2+=2;
//	cout<<b<<" "<<(sqrt(3)-1)*a/2<<endl;
	if(b>=(sqrt(3)-1)*a/2+a/2) ans1=3,b-=(sqrt(3)-1)*a/2+a/2;
	else ans1=1;
	ans1+=(int)(b/a)*2;
	cout<<max(ans1,ans2)<<endl;
}
int main(){
	solve();
	return 0;
}

#include<stdio.h>
#include<math.h>
int main()
{
    double r,h;
    int sum=0;
    scanf("%lf%lf",&r,&h);
    sum+=(int)h/r;
    h-=r*sum;
    sum*=2;
    if(h>=(sqrt(3)-1)/2.0*r+r/2.0)
        sum+=3;
    else if(h>=r/2.0)
        sum+=2;
    else
        sum+=1;
    printf("%d\n",sum);
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <fstream>
#include <set>
#include <map>
#include <utility>
#include <algorithm>
#include <cmath>
#include <queue>

#pragma comment(linker, "/STACK:258435456");

using namespace std;

int main()
{

    //ifstream cin("input.txt");
    //ofstream cout("output.txt");
    //cout.precision(5);
    //cout << fixed;

    long double r, h;
    cin >> r >> h;
    cout << max(2 * (int)((h + r / 2) / r), 1 + 2 * (int)(((1 - sqrt(3.0) / 2) + h / r)));

    return 0;
}

#include<iostream>
#include<cmath>
using namespace std;
int main()
{
    double r,h;
    int sum=0;
    cin>>r>>h;
    sum+=int(h/r)*2;
    if(h-r*sum/2>=sqrt(3)/2*r)
        cout<<sum+3<<endl;
    else if(h-int(r*sum/2)>=r/2)
        cout<<sum+2<<endl;
    else
        cout<<sum+1<<endl;
    //system("pause");
    return 0;
}
//3983458 7761504

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <cmath>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <deque>
#include <cstring>
#include <memory.h>
#include <bitset>
#include <time.h>
#define sf(x) scanf("%d", &x)
#define sff(x) scanf("%lf", &x)
#define sff2(x,y) scanf("%lf %lf", &x,&y)
#define sfc(x) scanf(" %c", &x)
#define pf(x) printf("%d ", x)
#define pff(x) printf("%lf", x)
#define pfc(x) printf("%c", x)
#define pfs(x) printf("%s", x)
#define sfl(x) scanf("%I64d", &x)
#define sfl2(x,y) scanf("%I64d %I64d", &x,&y)
#define ENDL printf("\n")
#define INF 2147483647
#define pf2(x,y) printf("%d %d ", x,y)
#define sf2(x,y) scanf("%d %d", &x,&y)
#define pb(x) push_back(x)
#define ppb() pop_back()
#define mp(x,y) make_pair(x,y)
#define sf3(x,y,z) scanf("%d %d %d", &x,&y,&z)
#define pf3(x,y,z) printf("%d %d %d", x,y,z)
#define print(x) puts(#x)
#define error(x) cerr<<#x<<' '<<x<<'\n'

using namespace std;

typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef vector<int> vec;

int main()
{
    /*
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    /**/

    int r,h;
    sf2(r,h);
    int res=((2.0*h+r)/2.0/r);
    res*=2;
    int res2=1+2*(int)((((h+r)-r*0.5*sqrt(3.0)))/r);
    pf(max(res,res2));
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
using namespace std;
int main()
{
	int r,l;
	scanf("%d%d",&r,&l);
	int ans=0;
	if (l>=r)
	{
		int k=l/r;
		ans+=2*k;
		double m=l-k*r;
		if (m>=(double)r/2)
		{
			ans+=2;
			m=m-(double)r/2;
			if (r+m>(sqrt(3)+1)*r/2)
				ans++;
		}
		else
			ans++;

		cout<<ans<<endl;
	}
	else
	{
		if (l<(double)r/2)
			ans=1;
		else
			ans=2;
		double m=l-(double)r/2;
		if (r+m>(sqrt(3)+1)*r/2)
				ans++;
		cout<<ans;
	}
	return 0;
}

#include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
using namespace std;
int main() {
	int r, h;
	cin >> r >> h;
	int cnt0 = h / r;
	cnt0 *= 2;
	long double ost = (h % r) + 0.0;
	long double r1 = sqrt(3.0) * (r + 0.0) / 2;
	long double r2 = (r + 0.0) / 2;
	if (ost >= r1-1e-6) {
		cout << cnt0 + 3;
		return 0;
	}
	if (ost >= r2-1e-6) {
		cout << cnt0 + 2;
		return 0;
	}
	else cout << cnt0 + 1;
}

#include <cstdlib>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <string>
#include <vector>
#include <queue>
#include <iomanip>

#define add push_back
#define create make_pair

using namespace std;

ifstream fin ("in.in");
ofstream fout ("out.out");

typedef unsigned long long ull;
const int N = 100000+10;
int r, h;

int main()
{
    //ios_base::sync_with_stdio(0);

    cin >> r >> h;

    int n = h/r*2;
    h %= r;

    if(!h)
        n++;

    else
    {
        if(2*h >= r) n += 2;
        else n++;

        if((h%r)*1.0 >= r*0.86602540378) n++;
    }

    cout << n;

    //system("PAUSE");
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define ld long double
#define pb 	push_back
#define endl '\n'
#define all(x) (x).begin(),(x).end()
#define mod 1000000007LL
#define F first
#define S second
#define fuck() cout<<"--------"<<endl
#define see(x) cout<<#x<<" = "<<x<<endl
int32_t main()
{
	ios_base::sync_with_stdio(0); cin.tie(0);cout.tie(0);
	int r,h;
	cin>>r>>h;
	int ans=0;
	if(h>=r)
	{
		int k=h/r;
		h-=k*r;
		ans+=2*k;
	}
	if(2*h>=r)ans+=2;
	else ans+=1;
	if(h*h*4>=3*r*r)ans+=1;
	cout<<ans;
}

#include <bits/stdc++.h>
#define int long long
using namespace std;
int r,h,ans;
int32_t main()
{
    cin>>r>>h;
    ans=(h/r)*2;
    h=h%r;
    if (2*h>=r)
    {
        ans+=2;
        if (4*h*h>=3*r*r) ans++;//h^2+(r/2)^2>=r^2
    }
    else ans++;
    cout<<ans;
    return 0;
}

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
    int h,r;

    cin>>r>>h;
    int ans;

    int interval= h%r;
    double in=interval;
        //cout<<in<<endl;
    ans= 2* (h/r);

        //cout<<ans<<endl;
    if(in==0)
        cout<< ans +1;

    else if(in>=(double)r*(sqrt(3))/(double)2)
    {
            //cout<<"yo";
        cout<<ans+3;
    }
    else if(in>=(double)r/(double)2&&in<(double)r*(sqrt(3))/(double)2)
    {
        cout<<ans+2;

    }

    else
    {
        cout<<ans+1;
    }

}

#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
//containers
#include<vector>
#include<list>
#include<map>
#include<queue>
#include<deque>
#include<set>
#include<string>
#include<stack>
#include<bitset>
//IOs
#include<iostream>
//algorithm & miscellaneous
#include<algorithm>
#include<utility>
#include<limits>
#include<locale>

using namespace std;

#define swap(x,y) x=x+y-(y=x)
#define mod 1000000007
#define ll long long
#define ull unsigned long long
#define s(a) scanf("%d",&a)
#define p(a) printf("%d",a)
#define ss(a) scanf("%s",a)
#define ps(a) printf("%s",a)
#define pc(a) printf("%c",a)
#define nline printf("\n")
#define ff first
#define rep(i,a,b) for(i=a;i<b;i++)
#define reprev(i,a,b) for(i=a;i>b;i--)
#define mk(x,y) make_pair(x,y)

int main()
{
    //freopen("input.txt","r",stdin);
    //freopen("output.txt","w",stdout);
    int i,h,n,ans;
    long long r;
    cin>>r;s(h);
    ans = h/r*2;
    long long int rem=h%r;
    if(rem>=(float)r/2.0)
    ans+=2;
    else
    ans++;
    if((rem*rem*4)>=(3*r*r))
    ans++;
    cout<<ans;
return 0;
}

#include <cstdio>

int main(){
    int h,r;
    scanf("%d %d",&r,&h);
    double m=(double)(h%r)/r;
    printf("%d",h/r*2+1+(m>0.495)+(m>0.866));
}

#include<iostream>
#include<cmath>
using namespace std;
int main()
{
    int r,h;
    while(cin>>r>>h)
    {
        int d=h/r;
        int sum=2*d;
        int remain=h-d*r;
       // cout<<remain<<endl;
        double jixian=r*sqrt(3)/2-r/2+r/2;
     //   cout<<"ji xian "<<jixian<<endl;
        double jixian2=(double)r/2;
    //    cout<<"jixian 2"<<jixian2<<endl;
        double remaind=r-remain;

        if(remain>=jixian)
        {
            sum+=2;
        }
        else if(remain>=jixian2)
        {
            sum+=1;
        }
        sum+=1;
        cout<<sum<<endl;
    }

}

#define NDEBUG

#include <bits/stdc++.h>

using namespace std;
using pii = pair<int, int>;

#ifdef NDEBUG
#  define debug(...)
#else
#  include "debug.hh"
#endif

int r, h;

int main() {
  ios_base::sync_with_stdio(false), cin.tie(0), cout << fixed;
  cin >> r >> h;
  int a = h/r;
  if (h%r*2 >= r) a++;
  int ans = 2*a;
  if (a > 0) {
    double b = h + r - (a - 0.5) * r;
    if (b >= sqrt(3)/2 * r + 0.5*r) ans++;
  } else {
    ans++;
  }
  cout << ans << endl;
  return 0;
}

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
using namespace std;

int main()
{
    double r, h;
    while(cin >> r >>h)
    {
        int ans=2*(int)((h+r/2)/r);
        ans=max(ans,1+2*(int)((h+r-sqrt(0.75)*r)/r));
        cout << ans <<endl;
    }
}

#include<bits/stdc++.h>
using namespace std;
#define int                 long long
#define ll                  long long
#define ld                  long double
#define rep(i,n)            for(int i=0;i<n;i++)
#define hell                1000000007
#define inf                 (ll)1e15
#define vi                  vector<int>
#define vii                 vector< vi >
#define pb                  push_back
#define mp                  make_pair
#define fi                  first
#define se                  second
#define pii                 pair<int,int>
#define all(c)              c.begin(),c.end()
#define sz(c)               (int)c.size()
#define hash1               105727LL
#define hash2               hell
#define eps                 1e-10
#define pi                  3.141592653589793238462643383279502884197
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
ll lcm(ll a, ll b) { return a * (b / gcd(a, b)); }
ll power(ll x, ll y,ll p)
{
    ll res=1;
    x=x%p;
    while(y>0)
    {
        if(y&1)
            res=((res%p)*(x%p))%p;
        y=y>>1;
        x=((x%p)*(x%p))%p;
    }
    return res;
}
ll raichu(ll x,ll y)
{
    ll res=1;
    while(y>0)
    {
        if(y&1)
            res=((res)*(x));
        y=y>>1;
        x=((x)*(x));
    }
    return res;
}
bool isprime(ll n)
{
    if(n<2) return false;
    else if(n==2) return true;
    else if(n%2==0) return false;
    else
    {
        ll z=sqrt(n);
        rep(i,z-1) if(n%(i+2)==0) return false;
        return true;
    }
}
int32_t main()
{
    //freopen("p099_base_exp.txt","r",stdin);
    //freopen("out1.txt","w",stdout);
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t=1,T;
    //cin>>t;
    T=t;
    while(t--)
    {
        int r,h;
        cin>>r>>h;
        int cnt=h/r;
        int ans=2*cnt;
        int left=h%r;
        if(((1.0*sqrt(3.0)*r)/2.0)<=(1.0*left)) ans+=3;
        else if(((1.0*r)/2.0)<=(1.0*left)) ans+=2;
        else ans+=1;
        cout<<ans;
    }
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
#include <stack>
#include <deque>
#include <iterator>
#include <tuple>
#include <iomanip>
#include <valarray>
#include <limits>
#include <sstream>
#include <cassert>
#include <functional>
#include <numeric>
#define pb push_back
#define mp make_pair
#define int long long
#define fi first
#define double long double
#define se second
#define endl '\n'
#define pii pair<int,int>
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);
#define mod 1000000007
#define MAXN  21
using namespace std;
int spf[MAXN];
int fac[MAXN];
void sieve()//sieve
{
    spf[1] = 1;
    for (int i=2; i<MAXN; i++)
        spf[i] = i;
    for (int i=4; i<MAXN; i+=2)
        spf[i] = 2;
    for (int i=3; i*i<MAXN; i++)
    {
        if (spf[i]==i)
        {
            for (int j=i*i; j<MAXN; j+=i)
                if (spf[j]==j)
                    spf[j]=i;
        }
    }
}//sieve ends
map<int,int> getfactor(int a)//factor prime
{
    map<int,int> m;
    while(a>1)
    {
        m[spf[a]]++;
        a/=spf[a];
    }
    return m;
}//prime factor ends
int power(int x,int y,int p)
{
    int res = 1;
    x = x % p;
    if (x == 0) return 0;
    while (y > 0)
    {
        if (y & 1)
            res = (res*x)% p;
        y = y>>1;
        x = (x*x)% p;
    }
    return res;
}
int gcd(int a, int b)
{
    if (a == 0)
        return b;
    return gcd(b % a, a);
}
int inverse(int a, int p)
{
    return power(a, p-2, p);
}
int ncr(int n, int r, int p)
{
    if (r==0)
        return 1;
    return (fac[n]*inverse(fac[r], p) % p *
            inverse(fac[n-r], p) % p) % p;
}
void solve()
{
    int r,h;
    cin>>r>>h;
    int ans=2*(h/r);
    double rem=h%r;
    double hh=(double)r/2;
    if(rem>=hh)
    {
        ans+=2;
        if(rem>=hh*sqrt(3))
            ans++;
    }
    else ans+=1;
    cout<<ans<<endl;
}
signed main()
{
    fast
    int t=1;
    while(t--)
    {
        solve();
    }
}

#include <bits/stdc++.h>
using namespace std;
#define TR(v,i) for(__typeof((v).begin())i=(v).begin();i!=(v).end();++i)
#define DEBUG(x) cout << #x << " = "; cout << x << endl;

int main(int argc, char const *argv[])
{
    #ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    // freopen("out", "w", stdout);
    #endif
    int h, r;   scanf("%d%d", &r, &h);
    int res = h/r * 2;
    double t = r + sqrt(3)/2 * r;
    int hh = h % r;
    if(hh + r >= t)
        res += 3;
    else if(hh >= r*1.0/2)
        res += 2;
    else
        res += 1;
    printf("%d\n", res);
    return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
#include<iostream>
#include<algorithm>
#include<iomanip>
#include<string>
#include<cmath>
#include<vector>
#include<set>
#include<queue>
#include<stack>
#include<fstream>
#include<map>
#include<bitset>
#include<unordered_map>
#include<cstring>
#include<cctype>
using namespace std;
#define  ll long long
#define  ull unsigned long long
#define  ul unsigned long
#define all(v) v.begin(),v.end()
#define sz(n) (int)n.size()
#define pb(s) push_back(s);
#define format(n) fixed<<setprecision(n)
#define finl "\n"
#define Mohammed_Atef_Hassan fast();
#define mod 1000000007
#define INF LLONG_MAX
#define PI acos(-1)
#define clr(dp,n) memset(dp,n,sizeof dp)
#define ex(n) return cout<<n<<finl,0;
int dx[] = { 0, 1, 0, -1, 1, 1, -1, -1 };
int dy[] = { 1, 0, -1, 0, 1, -1, 1, -1 };
ll fix_mod(ll x, ll y)
{
	return (y + x % y) % y;
}
void fast() {
	std::ios_base::sync_with_stdio(false);
	cin.tie(nullptr); cout.tie(nullptr);

#ifdef ONLINE_JUDGE
	//freopen("crosses.in", "r", stdin);

	//freopen("crosses.out", "w", stdout);
#endif
#ifndef ONLINE_JUDGE
	freopen("input.in", "r", stdin);
	freopen("output.out", "w", stdout);
#endif
}
int main()
{
	Mohammed_Atef_Hassan
		ll r, h;
	cin >> r >> h;
	ll res = (h / r) * 2;
	if ((h%r)*2 >= sqrt(3)*r)res += 3;
	else if ((h%r)*2>=r)res += 2;
	else res++;
	cout << res << finl;
}

#include <bits/stdc++.h>
#include <fstream>
#include<string>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

typedef  long long ll;
typedef long double ld;
using namespace std;
using namespace __gnu_pbds;
#define  point complex<double>
#define Cp(a,b) ((conj(a)*b).imag())
#define Dp(a,b) ((conj(a)*b).real())
#define dist(a,b) (abs(line(a,b)))
#define angel(a) (atan2(a.Y,a.X)*360/pi)

#define X real()
#define Y imag()

#define line(a,b) (b-a)

#define endl "\n"

#define FIO ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ordered_set tree<pair<int,int>, null_type,less<pair<int,int>>, rb_tree_tag,tree_order_statistics_node_update>
const int N=2e3+5;
ll mod=1e9+7;
ll inf=1e18;
ld eps=1e-8;
ld pi=2*2*acos(0);
ll mul (ll a, ll b)
{
    a%=mod;
    b%=mod;
    return (a*b)%mod;
}
ll add (ll a, ll b)
{
    a%=mod;
    b%=mod;
    return (a+b+mod)%mod;
}
ll fastpow(ll b, ll p)
{
    if(p==0)
        return 1;
    ll ans=fastpow(b,p/2);
    ans=mul(ans,ans);
    if(p%2)ans=mul(ans,b);
    return ans;
}
point takepoint()
{
    double x, y;
    cin>>x>>y;
    point p(x,y);
    return p;

}
bool isline(point a,point b,point c)
{
    return (fabs(Cp(line(a,b),line (a,c)))<eps);
}

pair<ld,point> getshort(point m , point a, point b)
{
    ld d=Dp(line(a,b),line(a,m));
    if (d<=0)
        return {dist(a,m),a};
    d=Dp(line(b,a),line(b,m));
    if (d<=0)
        return {dist(b,m),b};
    double w=(Dp(line(a,b),line(a,m)))/(Dp(line(a,b),line(a,b)));
    point x=a+w*line(a,b);

    return {dist(x,m),x};

}
bool is_par(point a,point b,point c,point d)
{

    ld a1=angel(line(a,b));
    ld a2=angel(line(c,d));
    ld a3=angel(line(d,c));
    return (fabs(a1-a2)<eps||fabs(a1-a3)<eps);

}
point get_inters(point a,point b,point c,point d)
{
    point z=line(a,b),zz=line(c,d);
    double t2=(z.X*a.Y-c.Y*z.X+z.Y*c.X-z.Y*a.X)/(zz.Y*z.X-zz.X*z.Y);
    return (c+zz*t2);
}
ld erea(point a,point b,point c)
{
    return (0.5*(fabs(Cp(line(a,b),line (b,c)))));
}
bool is_in_tra(point x,point a,point b, point c)
{
    ld e1=erea(a,b,c);
    ld e2=erea(a,b,x)+erea(a,x,c)+erea(x,b,c);

    return (fabs(e1-e2)<eps);
}
bool is_in_squ(point x, point a,point b, point c,point d)
{
    return (is_in_tra(x,a,b,c)||is_in_tra(x,a,c,d));
}
bool is_in_seg(point x, point a, point b)
{

    return (fabs(dist(a,b)-(dist(a,x)+dist(x,b)))<=eps);
}
bool is_in_ray(point x, point a, point b)
{
    if(is_in_seg(x,a,b))
        return 1;
    return (fabs((Dp(line(a,b),line(a,x))-(dist(a,x)*dist(a,b))))<=eps);
}

bool checkintersect( point a, point b,point c,point d)
{
    if (!(((Cp(line(a,b),line(a,c))*Cp(line(a,b),line(a,d)))<=eps)))
        return 0;
    point p=get_inters(a,b,c,d);
    return (is_in_seg(p,a,b)&&is_in_ray(p,c,d));
}

int is_rec(vector<point>v)
{
    for(int i=0; i<4; i++)
    {
        for(int j=i+1; j<4; j++)
        {
            for(int z=j+1; z<4; z++)
            {
                if(isline(v[i],v[j],v[z]))
                    return 0;

            }
        }

    }
    vector<ld>vv;
    for(int i=0; i<4; i++)
    {
        for(int j=i+1; j<4; j++)
        {
            ld d=dist(v[i],v[j]);
            bool found=0;
            for(auto it:vv)
            {
                if(fabs(d-it)<eps)
                {
                    found=1;
                    break;
                }
            }
            if(!found)
                vv.push_back(d);
        }
    }
    if (vv.size()>3)
        return 0;
    for(int it=0; it<vv.size(); it++)
        vv[it]*=vv[it];
    sort(vv.begin(),vv.end());

    if(vv.size()==2)
        return (fabs(2*(vv[0])-vv[1])<eps);
    return (fabs(vv[0]+vv[1]-vv[2])<eps)*-1;

}

double get_pos_ang(point x,point y)
{
    double a= angel(line(x,y));
    if(a<0)
        a+=180;
    return a;
}
double get_Y(point a,point b)
{
    if(fabs(b.X-a.X)<eps)
        return b.X;
    ld y=a.Y+(((-a.X)*(b.Y-a.Y))/(b.X-a.X));
    return y;
}
struct cmd
{
    bool operator()(double a, double b) const
    {
        return ((b-a)>eps) ;
    }
};
struct cmd2
{
    bool operator()(pair<double,double> a, pair<double,double> b) const
    {
        if(((b.first-a.first)>eps))
            return 1;
        if(((a.first-b.first)>eps))
            return 0;
        return (b.second-a.second>eps);

    }

};
bool is_in_rec(point a,point c,point x)
{
    ld mnx=min(a.X,c.X);
    ld mny=min(a.Y,c.Y);
    ld mxx=max(a.X,c.X);
    ld mxy=max(a.Y,c.Y);
    if(x.X-mnx<eps||eps>mxx-x.X)
        return 0;
    if(x.Y-mny<eps||eps>mxy-x.Y)
        return 0;
    return 1;
}
ld get_time(point x,point v,point p)
{
    if(v.X!=0)
    {
        ld t=(p.X-x.X)/v.X;
        return t;

    }
    return (p.Y-x.Y)/v.Y;

}
map<double,pair<int,int>>mp;
vector<pair<point,point>>v;
pair<ld,ld> get_mn_mx(point a,point c,point x,point v)
{
    if(v==point(0,0))
    {
        if(is_in_rec(a,c,x))
        {
            return {0,1e18};
        }
        cout<<"-1";
        exit(0);
    }
    point b(a.X,c.Y);
    point d(c.X,a.Y);
    point y=x+v;

    ld mn=1e18,mx=0;
    bool good=0;
    if(is_in_rec(a,c,x))
    {
        //  cout<<"in rec\n";
        mn=0,good=1;
    }
    //cout<<"a= "<<a<<" b= "<<b<<" x= "<<x<<" y= "<<y<<endl;
    if (checkintersect(a,b,x,y))
    {
        point p=get_inters(a,b,x,y);
        ld t=get_time(x,v,p);
        // cout<<"t1= "<<t<<endl;
        mn=min(mn,t);
        mx=max(mx,t);

        good=1;
    }
    if (checkintersect(a,d,x,y))
    {
        point p=get_inters(a,d,x,y);
        ld t=get_time(x,v,p);
        // cout<<"t2= "<<t<<endl;
        mn=min(mn,t);
        mx=max(mx,t);
        good=1;
    }
    if (checkintersect(b,c,x,y))
    {
        point p=get_inters(b,c,x,y);
        ld t=get_time(x,v,p);
        //  cout<<"t3= "<<t<<endl;
        mn=min(mn,t);
        mx=max(mx,t);
        good=1;
    }
    if (checkintersect(c,d,x,y))
    {
        point p=get_inters(c,d,x,y);
        ld t=get_time(x,v,p);
        //    cout<<"t4= "<<t<<endl;
        mn=min(mn,t);
        mx=max(mx,t);
        good=1;
    }
    if(!good)
    {
        cout<<-1;
        exit(0);
    }
    return {mn,mx};
}

int main()
{

    FIO
    ll r,h;
    cin>>r>>h;
    ll ans=(h/r)*2;
    h%=r;
    ///cout<<h<<" "<<r<<" "<<ans<<endl;
    if (h*100>=r*85)
    ans+=2;
    else if(h*2>=r)
        ans++;
    ans++;
    cout<<ans<<endl;
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cmath>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <ctime>

#define x first
#define y second
#define mp make_pair
#define pb push_back

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<ld, ld> point;
typedef pair<int, int> pii;

const int N = (int)(1e5) + 7;
const ld eps = 1e-15;
const ll MOD = (ll)(1e9) + 7;
const ll INF = (ll)(1e9) + 7;

int main()
{
    int r, h, kol;
    cin >> r >> h;
    int kk = h / r;
    kol = kk * 2;
    h -= kk * r;
    if (h * 2 >= r)
    {
        kol += 2;
        ld x = h * 1.0, y = r / 2.0;
        if (sqrt(x * x + y * y) + eps > r)
            ++kol;
    }
    else
        kol++;
    cout << kol << endl;
    return 0;
}

#include <iostream>
#include <cmath>
#include <string>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <memory.h>
#include <set>

using namespace std;
#define ll long long
#define pb push_back
#define pii pair<int, int>
#define pll pair<long long, long long>
#define mp make_pair
#pragma comment(linker, "/STACK:64000000")
int n, m, i, j, k, l, r, u, v, w;
const int maxn = 1e7 + 1;
const int maxm = 110;
const int maxmask = 1 << (maxn - 2);
const int infi = 1e9 + 7;
const int mod = 1e9 + 7;
const ll infl = 1e18 + 7;
const double eps = 1e-9;
pair <int, int> dp[maxn];
int h, res;
void init() {
    cin >> r >> h;
}
void solve() {
    double a, b, c, d;
    a = r, b = h;
    d = sqrt(3.0) * a / 2.0;
    double z = b - d + a;
    c = z / a;
    if (c < 0) {
        m = 1;
    }
    else {
        m = c;
        m *= 2;
        m += 1;
    }
    z = (b - a / 2.0) / a;
    if (z < 0) {
        n = 0;
    }
    else {
        n = z;
        n *= 2;
        n += 2;
    }
}
void out(){
    cout << max(m, n);
}
int main(){
  //  freopen("input.txt","r",stdin); freopen("output.txt","w",stdout);
//  freopen("tetris.in","r",stdin); freopen("tetris.out","w",stdout);
    init();
    solve();
    out();
    return 0;
}

#include <iostream>
#include <cmath>
using namespace std;
int r, h;
int ans;
void input()
{
	cin >> r >> h;
}
void solve()
{
	ans = h / r * 2;
//	h -= h / r * r;
	double t = h - h / r * r;
	if (t >= sqrt(3.0) * 0.5 * r)
		ans += 3;
	else if (t >= r * 0.5)
		ans += 2;
	else
		ans++;
	cout << ans << "\n";
}
int main()
{
	input();
	solve();
	return 0;
}

#include<iostream>
#include<cstring>
#include<string>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;

int main()
{
    double h,r;
    int sum=0;
    while(~scanf("%lf%lf",&r,&h))
    {
        int p=(int)(h/r);
        if(h-r*p>=r/2.0*(sqrt(3.0)))
            sum=p*2+3;
        else if(h-r*p>=r/2.0)
            sum=p*2+2;
        else
            sum=p*2+1;
        cout<<sum<<endl;
    }
    return 0;
}

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <complex>
#include <string>
#include <sstream>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <functional>
#include <iostream>
#include <map>
#include <set>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define INF 2000000000
#define sz(x) ((int)(x).size())
#define fi first
#define sec second
#define SORT(x) sort((x).begin(),(x).end())
#define all(x) (x).begin(),(x).end()
#define EQ(a,b) (abs((a)-(b))<EPS)
int main()
{
    int ans=0;
    int r,h;
    cin >> r >> h;
    int g;
    g=__gcd(r,h);
    r/=g;h/=g;
    int p=h/r;
    int q=h%r;
    ans+=2*p;
    if((double)q>(sqrt(3)/2.0*(double)r))ans+=3;
    else if(r<=2*q)ans+=2;
    else ans++;
    cout << ans << endl;
    return 0;
}

#include <stdio.h>
int main()
{
	int temp;
	int r,h;
	scanf("%d",&r);
scanf("%d",&h);

		temp=h/r;
		if(h-temp*r>=r/2.0)
			temp=temp*2+2;
		else
			temp=temp*2+1;
		printf("%d\n",temp);

	return 0;
}

#include <iostream>
#include <cmath>
#include <algorithm>
#include <string>
#include <list>
#include <vector>
#include <map>
#include <queue>

using namespace std;

int main()
{
    long long h, r;
    cin>>r>>h;
    cout<<max(
    (long long)(2 * (long long)(double( h ) / r + 0.5)),
    (long long)(1 + 2 * (long long)( h / r +1 - sqrt(3)/2 ))
    );
   // cout<<" "<<(long long)(2 * (long long)(double( h ) / r + 0.5))<<" "<<(long long)(1 + 2 * (long long)( h / r +1 - sqrt(3)/2 ));
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;
int main(){
	LL r, h; cin >> r >> h;
	LL ans = (h / r) * 2;
	if(2 * (h % r) >= r){
		ans += 2;
	} else ans += 1;
	cout << ans << "\n";
	return 0;
}

#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
//containers
#include<vector>
#include<list>
#include<map>
#include<queue>
#include<deque>
#include<set>
#include<string>
#include<stack>
#include<bitset>
//IOs
#include<iostream>
//algorithm & miscellaneous
#include<algorithm>
#include<utility>
#include<limits>
#include<locale>

using namespace std;

#define swap(x,y) x=x+y-(y=x)
#define mod 1000000007
#define ll long long
#define ull unsigned long long
#define s(a) scanf("%d",&a)
#define p(a) printf("%d",a)
#define ss(a) scanf("%s",a)
#define ps(a) printf("%s",a)
#define pc(a) printf("%c",a)
#define nline printf("\n")
#define ff first
#define rep(i,a,b) for(i=a;i<b;i++)
#define reprev(i,a,b) for(i=a;i>b;i--)
#define mk(x,y) make_pair(x,y)

int main()
{
    //freopen("input.txt","r",stdin);
    //freopen("output.txt","w",stdout);
    int h,r,n,i;
    s(r);s(h);
    int ans=h/r*2+1;
    p(ans);
return 0;
}

#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main()
{
    ll h,r,ans;
    cin>>r>>h;
    ans=(h/r)*2+1;
    if(((1.0*h)/r)-h/r>=0.5)ans++;
    cout<<ans<<endl;
}

#include <iostream>
#include <algorithm>
#include <string>
#include <cstdio>
#include <queue>
#include <vector>
#include <map>
using namespace std;

int main()
{
    int h,r;
    cin>>r>>h;
    printf("%d\n",max(2+(((2*h-r)/2)/r)*2,1+2*(h/r)));
}

#include <iostream>
#include <cmath>
using namespace std;

int main(){
	double r,h;
	cin>>r>>h;
	int s=0;
		float r3=pow(3,0.5);
	double d=h;

	while(d>=r*0.5){
		s=s+2;
		d=d-r;

	}
			int n=s/2;
		if(h-n*r<r and h-n*r>=0){

		float h2= (n-1)*r+0.5*r*(1+r3);
		if(h2<h+r) s++;
		}else if(h-n*r>=0.5*r) s++;

	//while()){
		/*
		s=int(h/r)*2;
		if(int(h)%int(r)>=((r)/2)) s=s+2;
		else s++;
			*/
		cout<<s;

	return 0;

}

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <cmath>
#include <string>
#include <cstring>
#include <ctime>
#include <cmath>

using namespace std;

#define ll long long
#define pii pair <int, int>
#define mp make_pair

int main() {
#ifdef _DEBUG
    freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
#endif
    int h, r;
    cin >> r >> h;
    cout << h * 2 / r + 1 << endl;
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define int                 long long
#define ll                  long long
#define ld                  long double
#define rep(i,n)            for(int i=0;i<n;i++)
#define hell                1000000007
#define inf                 (ll)1e15
#define vi                  vector<int>
#define vii                 vector< vi >
#define pb                  push_back
#define mp                  make_pair
#define fi                  first
#define se                  second
#define pii                 pair<int,int>
#define all(c)              c.begin(),c.end()
#define sz(c)               (int)c.size()
#define hash1               105727LL
#define hash2               hell
#define eps                 1e-10
#define pi                  3.141592653589793238462643383279502884197
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
ll lcm(ll a, ll b) { return a * (b / gcd(a, b)); }
ll power(ll x, ll y,ll p)
{
    ll res=1;
    x=x%p;
    while(y>0)
    {
        if(y&1)
            res=((res%p)*(x%p))%p;
        y=y>>1;
        x=((x%p)*(x%p))%p;
    }
    return res;
}
ll raichu(ll x,ll y)
{
    ll res=1;
    while(y>0)
    {
        if(y&1)
            res=((res)*(x));
        y=y>>1;
        x=((x)*(x));
    }
    return res;
}
bool isprime(ll n)
{
    if(n<2) return false;
    else if(n==2) return true;
    else if(n%2==0) return false;
    else
    {
        ll z=sqrt(n);
        rep(i,z-1) if(n%(i+2)==0) return false;
        return true;
    }
}
int32_t main()
{
    //freopen("p099_base_exp.txt","r",stdin);
    //freopen("out1.txt","w",stdout);
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t=1,T;
    //cin>>t;
    T=t;
    while(t--)
    {
        int r,h;
        cin>>r>>h;
        int cnt=h/r;
        int ans=2*cnt;
        int left=h%r;
        if(((1.0*r)/4.0+((1.0*r)/(2.0*sqrt(3.0))))<=(1.0*left)) ans+=3;
        else if(((1.0*r)/2.0)<=(1.0*left)) ans+=2;
        else ans+=1;
        cout<<ans;
    }
    return 0;
}

#include <iostream>
#include <cmath>
#include <cstring>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <set>
#include <queue>
#include <stack>
#include <map>
#include <algorithm>
#include <vector>

using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
#define INF 0x3f3f3f3f
#define MAXN 1e5
const double PI=acos(-1.0);
const double EPS=1e-6;

int main()
{
    double h,r;
    cin>>r>>h;
    int s=(int)h/r;
    if(h-r*s>r/2){
        printf("%d\n",2*(s+1));
    }else{
        printf("%d\n",2*s+1);
    }
    return 0;
}

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<stack>
#include<queue>
using namespace std;

#define pi 1.57

int h,r;

int main()
{
    while(scanf("%d%d",&r,&h)!=EOF)
    {
        if(h*2==r)
            printf("2\n");
        else
            printf("%d\n",1+2*h/r);
    }
	return 0;
}

#include <cstdio>
#include <cmath>
using namespace std;
const double eps = 1e-8;
const double cc = sqrt(3.0);

int main()
{

    int r, h, ans;
    double d, d2;
    while(scanf("%d%d", &r, &h) != EOF)
    {
        if(h == r)
            ans = 3;
        else if(h > r)
        {
            ans = h / r * 2 + 1;
            d = h - h / r + r / 2;
            d2 = cc * r * 0.5;
            if(fabs(d - d2 - r * 0.5) < eps || !(fabs(d - d2 - r * 0.5) < eps) && (d - d2 - r * 0.5) > 0)
                ans++;
        }
        else if(h < r)
        {
            if(h >= r * 0.5)
            ans = 2;
            else
            ans = 1;
        }

        printf("%d\n", ans);
    }
}

#include <bits/stdc++.h>
#define ll int
#define FOR(i,a,b) for(i=a;i<=b;i++)
#define inf 1000000007
using namespace std;
int main()
{
    ll i,j,k,n,t,m,d=0;
    ll r,h;
    cin>>r>>h;
    d = 2*(h/r);
    h = h - r*(h/r);
    if(2*h>=r) d+=2;
    else d++;
    cout<<d;
    return 0;
}

#include<bits/stdc++.h>

using namespace std;

int main()

{

	int r,h;

	scanf("%d%d",&r,&h);

	if(h*h>=3/4*r*r) printf("%d\n",2*h/r+1);

	else

	{

		if(h>r/2) printf("2\n");

		else printf("1\n");

	}

	return 0;

}

#include <bits/stdc++.h>
using namespace std;
int main(){
    int r,h;
    cin>>r>>h;
    int res=h/r*2;

    if(2*(h%r)>=r){
       res+=2;

       double t=(double)r*r + (double)r*r/4;
       t=sqrt(t);
       if(t-(h%r) <= r/2.0)res++;
    }
    else res++;

    cout<<res<<"\n";

}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cmath>
using namespace std;

int main(void)
{

	long long int r, h;
	cin >> r >> h;
	if (h % r == 0)
		cout << 2*(h / r) + 1 << endl;
	else
	{
		cout << (2*(h / r)) + ((h % r > 1) ? 2 : 1) << endl;;
	}

	return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <cmath>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <cmath>
#include <fstream>
#include <time.h>
#include <sstream>
#include <stdio.h>
#include <cstring>
#include <queue>
#include <deque>
#include <stack>
using namespace std;

#define ll long long
#define ul unsigned long long
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define REP(i, n) for (int (i) = 0; (i) < (n); (i) ++)
#define wait system("pause")

int main()
{
    int h,r;
    int k = 0;
    cin>>r>>h;
    if (h % r == 0)
    {
        k = (h/r)*2 + 1;
    }
    else
    {
        k = (h/r)*2;
        if ((double)(h % r ) < ((double)(r)/2.0))
            k++;
        else k+=2;
    }
    cout<<k<<'\n';
    //wait;
    return 0;
}

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <cmath>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <deque>
#include <cstring>
#include <memory.h>
#include <bitset>
#include <time.h>
#define sf(x) scanf("%d", &x)
#define sff(x) scanf("%lf", &x)
#define sff2(x,y) scanf("%lf %lf", &x,&y)
#define sfc(x) scanf(" %c", &x)
#define pf(x) printf("%d ", x)
#define pff(x) printf("%lf", x)
#define pfc(x) printf("%c", x)
#define pfs(x) printf("%s", x)
#define sfl(x) scanf("%I64d", &x)
#define sfl2(x,y) scanf("%I64d %I64d", &x,&y)
#define ENDL printf("\n")
#define INF 2147483647
#define pf2(x,y) printf("%d %d ", x,y)
#define sf2(x,y) scanf("%d %d", &x,&y)
#define pb(x) push_back(x)
#define ppb() pop_back()
#define mp(x,y) make_pair(x,y)
#define sf3(x,y,z) scanf("%d %d %d", &x,&y,&z)
#define pf3(x,y,z) printf("%d %d %d", x,y,z)
#define print(x) puts(#x)
#define error(x) cerr<<#x<<' '<<x<<'\n'

using namespace std;

typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef vector<int> vec;

int main()
{
    /*
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    /**/

    ll r,h;
    cin>>r>>h;
    int res=((2*h+r)/(2*r));
    res*=2;
    int res2=1+((int)(2*h+r*(2-sqrt(3.0)))/r);
    pf(max(res,res2));
    return 0;
}

#include <cstdio>

using namespace std;
int h,r,sol;

int main (void){
    scanf("%d%d", &r, &h);
    sol=2*(h/r);
    h%=r;
    sol++;
    if (h>=r/4&&h){
        sol++;
    }
    printf("%d\n", sol);
    return 0;
}

#include<stdio.h>
//#include<conio.h>
#include<math.h>
const float c=((sqrt(3)-1)/sqrt(12));
//const float c=2-sqrt(3);
int h,r;
int main()
{
    //freopen("BALLOON.TXT","r",stdin);
    scanf("%d%d",&r,&h);
    int s=0;
    while(2*h>=r)
    {
        s+=2;
        h-=r;

    };
    if(float(h>-(r*c)))
    s=s+1;
    printf("%d",s);
//  getch();
}

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define sz(x) (int)(x.size())
#define double long double

signed main() {
    ios::sync_with_stdio(false); cin.tie(nullptr);
	int r, h;
	cin >> r >> h;
	int ans = 2 * (h / r);
	int baq = h - (h / r) * r;
	if (baq * 2 < r) {
		ans++;
	} else {
		ans += 2;
		double x1 = r / 2.0, y1 = x1, x2 = r, y2 = baq + r / 2.0;
		if (sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) >= 2.0 * r)
			ans++;
	}
	cout << ans << "\n";
}

#include <iostream>
using namespace std;
double r, h;
int ans;
void input()
{
	cin >> r >> h;
}
void solve()
{
	ans += h / r * 2;
	h -= h / r;
	if (h >= r / 2.0)
		ans += 2;
	else
		ans++;
	cout << ans << "\n";
}
int main()
{
	input();
	solve();
	return 0;
}

#include<iostream>
using namespace std;
main()
{
    int r , h , ans;
    cin>>r>>h;
    ans = (h/r)*2 + 1;
    cout<<ans;
}

/*
 Author: Abdulla Ashraf
 Idea:
 -
 */

#include <bits/stdc++.h>

using namespace std;

#define pb push_back
#define mp make_pair
#define sz(x) ((int)(x).size())
#define sqr(x) ((x) * (x))
#define INF ((int)1e9)

typedef long long ll;

const int N = 10005;
const double PI = acos(-1.0);
const double EPS = 1e-9;

int main() {
	//freopen("in.txt","r",stdin);
	//freopen("out.txt","w",stdout);
	int r, h;
	cin >> r >> h;
	double t = r / 2.0;
	t = (t - t * sqrt(3) / 2);
	if ((r - h % r) <= t)
		cout << 3 + 2 * (h / r);
	else if ((r - h % r) <= r / 2.0)
		cout << 2 + 2 * (h / r);
	else
		cout << 1 + 2 * (h / r);
	return 0;
}

#include <bits/stdc++.h>
#include <fstream>
#include <cfloat>

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;

using namespace std;

double Fib(double x,double z);
string BinDec(ull x);
string StringInt(ll x);
ull StringInt(string x);
ull BinDec (string x);
ull POWMOD (ull x,ull y,ull mod);
ull POWE(long long , long long);

ll fast_pow(ll a,ll b,ll mod)
{
	if(b==0)
		return 1ll;
	ll ans=1;
	if(b%2)
		return ans=(fast_pow(a,b-1,mod)*a)%mod;
	ans=(fast_pow(a,b/2,mod)%mod);
	return ((ans*ans)%mod);
}

int main()
{
   // freopen("tshirts.in","r",stdin);
    //freopen("game.out","w",stdout);
    ios::sync_with_stdio(false);
    cin.tie(0);

    ll x,y,z,zz;

    long long a,b,c;
    cin>>x>>y;
    b=x;c=y;
    a=y/x*2;

    if(y>=x/2.0)a++;
    else a++;
    cout<<a;

    return 0;
}

#include<cstdio>
const double eps=1e-16;
int main(){
    int h,r;
    scanf("%d%d",&r,&h);
    if((h%r)*2<r){
        double x=r/2.0;
        double y=x-h%r;
        if(x*x+y*y<0.25*r*r+eps)
            printf("%d\n",h/r*2+2);
        else
            printf("%d\n",h/r*2+1);
        }
    else{
        double y=0.75*r*r-h%r;
        if(y>eps)
            printf("%d\n",h/r*2+2);
        else
            printf("%d\n",h/r*2+3);
    }
    return 0;
}

#include <bits/stdc++.h>

using namespace std;

int main(){
    int n,r,ans;cin>>r>>n;
    ans = round((2*n +r)/r);
    cout << ans ;
}

#include <bits/stdc++.h>

using namespace std;

const int OO = (int) 1e9;
const double eps = 1e-10;

#define db(x) 			cout<<"> "<<#x<<" = "<<(x)<<'\n'
#define db2(x,y) 		cout<<"> "<<#x<<" = "<<(x)<<", "<<#y<<" = "<<(y)<<'\n'
#define db3(x,y,z) 		cout<<"> "<<#x<<" = "<<(x)<<", "<<#y<<" = "<<(y)<<", "<<#z<<" = "<<(z)<<'\n'
#define sz(v) 			int(v.size())
#define trav(a,x) 		for(auto&a:x)
#define rep(i,v)		for(int i=0;i<sz(v);++i)
#define lp(i,n) 		for(int i=0;i<int(n);++i)
#define lpi(i,j,n) 		for(int i=j;i<int(n);++i)
#define lpd(i,j,n) 		for(int i=j;i>=int(n);--i)
#define ndl 			cout<<'\n'
#define all(v) 			v.begin(),v.end()
#define rall(v) 		v.rbegin(),v.rend()
#define present(a,x) 	(a.find(x)!=a.end())
#define cpresent(a,x) 	(find(all(a),x)!=a.end())
#define clr(v, d) 		memset(v,d,sizeof(v))
#define pb 				push_back
#define mp 				make_pair
#define fs 				first
#define sc 				second

typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vector<int> > vvi;
typedef map<int, int> mii;
typedef set<int> si;

int r,h;

int main() {
	ios::sync_with_stdio(false);
	cin>>r>>h;
	cout<<max(1+h/r*2,int(h+.5*r)/r*2)<<'\n';
	return 0;
}

#include <iostream>
using namespace std;

main()
{
      float r, h; int ans = 0, mod;

      cin >> r >> h;

      ans += (int)h / (int)r * 2;

      mod = (int)h % (int)r;

      if (mod >= r / 2)
         ans += 2;
      else
         ans++;
      if (mod >= r / 5 * 4)
         ans++;
cout << ans ;
cin >> r;
return 0;
}

#include<iostream>
#include<cstdio>
#include<string.h>
#include<algorithm>
#include<math.h>
#include<vector>
using namespace std;
double e = 1e-6 ;
long long max(long long a,long long b)
{
    return a>b?a:b;
}
int main()
{
    double r,h;
    cin>>r>>h ;
    int ans = 0 ;
    int t = h/r*2 ;
    ans = max(ans,t+1) ;
    if(h>r/2||fabs(h-r/2)<e)
    {
        ans = max(ans,(h-r/2)/r*2+2) ;
    //  ans = max(ans,(h-(sqrt(3)-1)/2*r)/r+3) ;
    }
    if(h>(sqrt(3))/2*r||fabs(h-(sqrt(3))/2*r)<3)
    {
        ans = max(ans,(h-(sqrt(3))/2*r)/r*2+3) ;
    }
    cout<<ans<<endl;
    return 0 ;
}

//In The Name Of God

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;

const ll Maxn = 3e6 + 270;
const ll Inf = 1e9 + 7;
const ll Mod = 1e9 + 7;
const ll Max = 5e2 + 7;

#define mp make_pair
#define pb push_back
#define F first
#define S second

int main()
{
    ld h,r;
    cin>>r>>h;
    ld ans1=2*(ll)((h+0.5*r)/r);
    ld ans2=1+2*(ll)(h/r+1-1.73205/2);
    cout<<max(ans1,ans2)<<endl;
}

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
#include <sstream>
#include <iomanip>
#include <map>
#include <string>
#include <numeric>
#include <cmath>
#include <climits>

#define MOD 1000000007

using namespace std;

struct point {
    long double x, y;
};

long double magn(point p) {
    return sqrt(p.x * p.x + p.y * p.y);
}

long double dotprod(point a, point b) {
    return a.x * b.x + a.y * b.y;
}

point proj(point a, point b) {
    long double k = magn(b);
    b.x = b.x * 1.0 / k;
    b.y = b.y * 1.0 / k;
    //cout << "a: " << a.x << " " << a.y << endl;
    //cout << "normed: " << b.x << " " << b.y << endl;
    long double inc = dotprod(a, b);
    //cout << "inc: " << inc << endl;
    b.x *= inc;
    b.y *= inc;
    return b;
}

long double dist(point a, point b, point c) {
    point line;
    line.x = b.x - c.x;
    line.y = b.y - c.y;
    a.x -= c.x;
    a.y -= c.y;
    point p = proj(a, line);
    //cout << "proj: " << p.x << " " << p.y << endl;
    a.x -= p.x;
    a.y -= p.y;
    return magn(a);
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    long double r, h; cin >> r >> h;
    long double effh = h + r / 2;
    long double initial = floor(effh/ r) * 2;
    long double highestp = (initial / 2) * r - r / 2;
    long double pos = h + r / 2;
    //cout << highestp << " " << pos << endl;
    if(pos - highestp >= r * sqrt(3)/2) initial += 1;
    cout << initial << endl;
}

//Saatwik Singh Nagpal
#include <bits/stdc++.h>
using namespace std;
int main()
{
	int h,r;
    cin>>r>>h;
    int ans=h/r;
    double tmp = (double)h/(double)r;
    if(tmp-ans<=0.5 && tmp-ans>0){
        ans*=2;
        ans+=2;
    }
    else{
        ans*=2;
        ans++;
    }
    cout<<ans<<endl;
    return 0;
}

#include<cstdio>
#include<iostream>
#include<math.h>
using namespace std;
int main()
{
	int h,r;
	cin>>r>>h;
	int m,n,p,q,u,v;
	p=(r+1)/2;
	q=(((sqrt(3.0)-1)*r+1)/2)+1;
	u=(h-p)/r;
	v=(h+r-q)/r;
	m=2+2*u;
	n=1+2*v;
	if(m>n) cout<<m;
	else cout<<n;
	//system("pause");
	return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main()
{ int r, h;
cin>>r>>h;
if ((2*h)%r>r/2) cout<<2*h/r+2;
else cout<<2*h/r+1;
return 0;
}

#include <bits/stdc++.h>

using namespace std;

#define reps(i, s, n) for(int i=s; i<n; i++)
#define rep(i, n) reps(i, 0, n)
#define dreps(i, s, n) for(int i=n-1; i>=s; i--)
#define drep(i, n) dreps(i, 0, n)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define foreach(v, c) for(__typeof((c).begin()) v=(c).begin();v!=(c).end(); ++v)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define in(a,b) ((b).find(a) != (b).end())
#define cpresent(c,x) (find(all(c),x) != (c).end())
#define X real()
#define Y imag()
#define length(V) (hypot((V).X, (V).Y))

typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
typedef long long ll;
typedef long double ld;
typedef complex<double> point;
typedef pair<point, point> segment;
typedef pair<double, point> circle;
typedef vector<point> polygon;

const double PI = 2 * acos(0.0);
const double eps = 1e-9;

double r, h;

int main() {
   cin >> r >> h;
   int ans = 0;
   double half = floor(h / r);
   ans += half * 2;
   h = h - half * r;
   if (h * r < r) ans ++;
   else if (h * 2 >= sqrt(3)) ans += 3;
   else ans += 2;
   cout << ans << endl;
   return 0;
}

#include<bits/stdc++.h>

#define eps 1e-20

#define inf 1e100

#define squ(a,b) (a)*(a)+(b)*(b)

using namespace std;

typedef double DO;

//2-dimension point struct (double)

struct point {

	DO x, y;

	point (DO x=0, DO y=0) : x(x), y(y) {}

	point operator - (point a) {return point(x-a.x, y-a.y);}

	point operator + (point a) {return point(x+a.x, y+a.y);}

	point operator * (DO a) {return point(x*a, y*a);}

	point operator / (DO a) {return point(x/a, y/a);}

	point operator & (point a) {return point(x*a.x-y*a.y, x*a.y+y*a.x);}

	point rotate(DO al) {return *this&point(cos(al), sin(al));}

	DO    operator ^ (point a) {return x*a.y-y*a.x;}

	DO    operator * (point a) {return x*a.x+y*a.y;}

	point norm() {DO s=nor(); if (s<eps) return *this; return point(x/s, y/s);}

	point conj() {return point(-y, x);}

	DO nor() {return sqrt(*this**this);}

	DO al() {return atan2(y, x);}

	bool operator < (const point &a) const {

		if (fabs(x-a.x)>eps) return x<a.x;

		return y<a.y-eps;

	}

	bool operator > (const point &a) const {

		if (fabs(x-a.x)>eps) return x>a.x;

		return y>a.y+eps;

	}

	bool operator == (const point &a) const {

		if (fabs(x-a.x)>eps) return 0;

		return fabs(y-a.y)<eps;

	}

	bool operator != (const point &a) const {

		if(*this==a) return false;

		return true;

	}

	void input() {scanf("%lf %lf", &x, &y);}

	void print() {printf("%lf %lf\n", x, y);}

};

double dist(point a, point b){

	return sqrt(squ(a.x-b.x,a.y-b.y));

}

int sgn(DO a) {return (a>eps)-(a<-eps);}

bool is_on(point a, point b, point c) {

	if (sgn(a-b^b-c)) return 0;

	return sgn((a-c)*(b-c))<=0;

}

bool intersect(point a, point b, point c, point d, point &ans) {

	if (min(a.x, b.x)>max(c.x, d.x)+eps) return 0;

	if (max(a.x, b.x)<min(c.x, d.x)-eps) return 0;

	if (min(a.y, b.y)>max(c.y, d.y)+eps) return 0;

	if (max(a.y, b.y)<min(c.y, d.y)-eps) return 0;

	if (sgn((a-b)^(c-b))*sgn((a-b)^(d-b))>=0) return 0;

	if (sgn((c-d)^(a-d))*sgn((c-d)^(b-d))>=0) return 0;

	DO sc=fabs((a-b)^(b-c)), sd=fabs((a-b)^(b-d));

	ans=(c*sd+d*sc)/(sc+sd);

	return 1;

}

DO angle(point a, point b) {

	DO res=a*b/a.nor()/b.nor();

	res=acos(res);

	return res;

}

DO angle(point a, point b, point c) {

	return angle(a-c, b-c);

}

DO pdist(point c, point a, point b) {

	point aa=c-a, bb=c-b, ab=a-b;

	if(sgn(aa*ab)>=0) return aa.nor();

	if(sgn(bb*ab)<=0) return bb.nor();

	return fabs(aa^bb)/ab.nor();

}

bool is_in_poly(point a, point *p, int n) {

	for (int i=0; i<n; i++) if (is_on(p[i], p[i+1], a)) return 1;

	int cnt=0;

	for (int i=0; i<n; i++) {

		point b=p[i], c=p[i+1];

		if (b>c) swap(b, c);

		if (sgn(c-b^a-b)<0 && b.x<a.x-eps && a.x<c.x+eps) cnt++;

	}

	return cnt&1;

}

int main(){

	DO h,r;

	scanf("%lf%lf",&r,&h);

	if(h<r-eps){

		printf("1");

		return 0;

	}

//	puts("1");

	int k=h/r; h-=r*k; k*=2; r/=2;

	if(h<r/2-eps){

		printf("%d\n",k+1);

		return 0;

	}

//	puts("2");

	h-=r;

	if(h<(sqrt(3)-1)*r-eps) {

		printf("%d",k+2);

		return 0;

	}

//	puts("3");

	printf("%d",k+3);

	return 0;

}

#include<stdio.h>
int main()
{
    long long r,h,i,j;
    scanf("%lld%lld",&r,&h);
    i=h%r;
    j=h/r*2;
    if(i==0)
       j++;
    else if(i<=r/2)
       j+=2;
    printf("%lld\n",j);
    return 0;
}

#include<bits/stdc++.h>

using namespace std;

long long mod=1000000007;

long long add(long long x,long long y){
    return (x+y)%mod;
}

long long sub(long long x,long long y){

    return (x-y+mod)%mod;
}

long long mul(long long x,long long y){
    return ((x%mod)*(y%mod))%mod;
}

long long poww(long long x,long long y){

    if(y==0)return 1;

    long long xx=poww(x,y/2LL);
    xx=mul(xx,xx);
    if(y&1)
    xx=mul(xx,x);
    return xx;

}

long long divv(long long x,long long y){
    long long yinv=poww(y,mod-2LL);
    return mul(x,yinv);
}

int main(){
    ios::sync_with_stdio(false);
    int r,h;
    cin>>r>>h;
    cout<<max(1+2*((2*h+r)/(2*r)),2*((r+2*h)/(2*r)));
    return 0;
}

/*************************************************************************
    > File Name: c.cpp
    > Author: Nature
    > Mail: 564374850@qq.com
    > Created Time: Tue 28 Oct 2014 11:12:26 PM CST
************************************************************************/

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <iostream>
#include <algorithm>
using namespace std;
#define lp (p << 1)
#define rp (p << 1|1)
#define getmid(l,r) (l + (r - l) / 2)
#define MP(a,b) make_pair(a,b)
typedef long long ll;
const int INF = 1 << 30;
const double the = sqrt(3.0);
const double eps = 1e-8;

double R,r,h;
int k,ans1 = 0,ans2 = 0,th;

int main(){
	cin >> R >> h;
	r = R / 2.0;
	k = (int)(h / R);
	if(h - (k * R + the * r / 2.0 + r) > eps)
		ans1 = 1;
	ans1 += 2 * k + 1;

	k = (int)((h - r) / R);
	if(h - r - (k * R + the * r / 2.0 + r) > eps)
		ans2 = 1;
	ans2 += 2 * k + 2;
	cout << max(ans1,ans2) << endl;
	return 0;
}

#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <iterator>
#include <utility>
using namespace std;

#define sc(a) scanf("%d",&a)
#define scm(a,b) scanf("%I64d%I64d",&a,&b)
#define fl(c,i,n) for(i=c;i<n;i++)
#define f(i,n) for(i=0;i<n;i++)
#define mem(a) memset(a,0,sizeof(a))
#define ll long long int
#define ull unsigned long long int
#define inf INT_MAX
#define linf LLONG_MAX
#define pb push_back
#define pp pop_back()
#define aov(a) a.begin(),a.end()
#define mpr make_pair
#define nl printf("\n")
#define PI 2.0*acos(0.0) //#define PI acos(-1.0)
#define xx first
#define yy second
#define mxv(a) *max_element(aov(a))
#define mnv(a) *min_element(aov(a))
#define LB(a,x) (lower_bound(aov(a),x)-a.begin())
#define UB(a,x) (upper_bound(aov(a),x)-a.begin())
#define to_c_string(a) a.c_str()
#define strtoint(c) atoi(&c[0])
#define COUT(x) #x
#define pii pair<int,int>

template <class T> inline T bigmod(T p,T e,T M){ll ret = 1;for(; e > 0; e >>= 1){if(e & 1) ret = (ret * p) % M;p = (p * p) % M;} return (T)ret;}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

int toInt(string s)  { int sm; stringstream ss(s); ss>>sm; return sm; }
int toLlint(string s) { long long int sm; stringstream ss(s); ss>>sm; return sm;}

///int month[]={-1,31,28,31,30,31,30,31,31,30,31,30,31};  //Not Leap Year
///int dx[]={1,0,-1,0};int dy[]={0,1,0,-1}; //4 Direction
///int dx[]={1,1,0,-1,-1,-1,0,1};int dy[]={0,1,1,1,0,-1,-1,-1};//8 direction
///int dx[]={2,1,-1,-2,-2,-1,1,2};int dy[]={1,2,2,1,-1,-2,-2,-1};//Knight Direction
///int dx[]={-1,-1,+0,+1,+1,+0};int dy[]={-1,+1,+2,+1,-1,-2}; //Hexagonal Direction

/*****************************************************************/
///////////////////////   GET SET GO    ///////////////////////////
/*****************************************************************/

#define M 1000

int main ()
{
    ll cs=1,t,i,j,h,r;
    double d;
    //while(1){

        scm(r,h);

        i=(h/r)*2;
        h=h%r;

        if(h>=sqrt(3)/2*r)
            i+=3;
        else if(d>=1.0/2*r)
            i+=2;
        else
            i++;
        printf("%I64d\n",i);
    //}

    return 0;
}

#include <bits/stdc++.h>

using namespace std;

constexpr int N = 1e6 + 10;
constexpr int MOD = 1e9 + 7;

long long r, h, ans;

int main() {
    ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin >> r >> h;
    ans = h / r;
    ans *= 2;
    if (h % r == 0) {
        ans++;
    }
    else {
        double x = r;
        x /= 2;
        double can = sqrt(3) * x;
        can /= 2;
        can += x;
        h %= r;
        if (h + r <= can)
            ans += 3;
        else if (h >= x)
            ans += 2;
        else
            ans++;
    }
    cout << ans << '\n';
    return 0;
}

#include<stdio.h>
#include<math.h>
int max(int a,int b)
{
    return a<b?b:a;
}

#define PI acos(-1.0)

int r,h;

int main()
{
    while(~scanf("%d%d",&r,&h))
    {
        int ans1=h/r*2+1;
        int ans2=2+((int)(h-r*1.0/2))/r*2;
        printf("%d\n",max(ans1,ans2));
    }
    return 0;

}

#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;

#define rv(x) reverse((x).begin(), (x).end())
#define sq(x) (x)*(x)
#define ll long long
#define pi pair<int, int>

#define INF 987654321

int main(void)
{
    int r, h;   cin >> r >> h;

    int ans = 0;
    ans += (h / r) * 2;

    int remain = h % r;

    cout << remain << " " << sqrt((double)3)*r << endl;
    if(remain < (r/2.0))  ans += 1;
    else if(remain < sqrt((double)3)*r/2.0) ans += 2;
    else    ans += 3;

    cout << ans << endl;
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cmath>
int main()
{
	int h,r;
	while(scanf("%d%d",&r,&h)!=EOF){
		if(h%r==0){
			printf("%d\n",(h/r)*2+1);
		}
		else{
			int sum=(h/r)*2;
			int s=h%r;
			double t=sqrt(3.0)*r/2.0;
			double m=r/2;
			if(s>=t){
				printf("%d\n",sum+3);
			}
			else if(double(s)>=m){
				printf("%d\n",sum+2);
			}
			else printf("%d\n",sum+1);
		}
	}
	return 0;
}

#include <iostream>
#include <cstdio>
#include <vector>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
#include <cstdlib>  // for atoi
#include <sstream>  // for stringstream
#include <cmath>        // for sqrt
#include <cstring>  // for memset
using namespace std;

#define rv(x) reverse((x).begin(), (x).end())
#define sq(x) (x)*(x)
#define ll long long
#define pi pair<int, int>

#define INF 987654321

int main(void)
{
    int r, h;   cin >> r >> h;

    int ans = 0;
    ans += (h / r) * 2;

    if((h % r)*2 >= r)  ans += 2;
    else                ans++;

    cout << ans << endl;
    return 0;
}

#include<stdio.h>
//#include<conio.h>
#include<math.h>
const float c=((1-sqrt(3))/2);
long int h,r;
int main()
{
    //freopen("BALLOON.TXT","r",stdin);
    scanf("%ld%ld",&r,&h);
    long int s=0;
    while(h>=r)
    {
        s+=2;
        h-=r;
    }
    if(float(h-c*r)>0)
    s=s+1;
    printf("%ld",s);
    //getch();
}

//we will remain strangers
//after so many meets

#include<bits/stdc++.h>
#include<algorithm>
#include <fstream>
#include <sstream>
#include <string>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp>
#include <functional> // for less
#include <iostream>
using namespace std;
using namespace __gnu_pbds;
using namespace std;

// Declaring ordered_set

typedef tree<int, null_type, less<int>, rb_tree_tag,
            tree_order_statistics_node_update>
    ordered_set;
#define pf push_front

#define pb push_back
#define pob pop_back
#define pof pop_front
#define is insert
#define rep1(i,a,b) for(long long i=a;i<=b;i++)
#define mp make_pair
#define F first
#define S second
//#define fin cin
//#define fout cout
#define file ifstream fin("input.txt");ofstream fout("output.txt");
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define fr(n) for(long long i=0;i<n;i++)
#define rep(i,a,b) for(long long i=a;i<b;i++)
#define ALL(x) (x).begin(), (x).end()
typedef long long int ll;
#define int long long
#define ld long double
typedef pair<ll,ll> pairs;
typedef vector<ll> vi;
typedef vector<pairs> vpair;
void solve()
{
    ll r,h;cin>>r>>h;
    ll div=h/r,mod=h%r;
    ll ans=2*div;
    if((2*mod)>=(r))
        ans+=2;
    else
        ans+=1;
    cout<<ans<<endl;

}

int32_t main(){
    fast;
	ll t=1;
	//cin>>t;
	fr(t)
	solve();
}

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <utility>
#include <cmath>
#include <queue>
#include <cstdlib>
#include <cstring>
#define reset(a , b) memset(a , b , sizeof(a))

using namespace std;

const int INF = 1000000007;
const int N = 100100;

double delta;
long long h , r;
long long ans , ok;

int main() {
    //freopen("input.in", "r" , stdin);
    //freopen("output.out" , "w" , stdout);
    cin >> r >> h;
    ans = h / r;
    h %= r;
    if (h >= r / 2) ok = 2;
    if (r - h >= sqrt(double(3)) * r/2) ok = 3;
    if (!h) ok = 1;
    cout << ans * 2 + ok;
}

#pragma  comment(linker, "/STACK:36777216")
#include <iostream>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <vector>
#include <stdlib.h>
#include <map>
#include <queue>
#include <algorithm>
#define  lowbit(x) (x&(-x))
#define  lc(x) (x<<1)
#define  rc(x) (lc(x)+1)
#define  pi    (acos(-1))
#define  eps   1e-8
#define  maxn  10000
#define  maxm  50005
#define  ll    long long
#define  ull   unsigned long long
#define  inf   0x7fffffffffffffffll
#define  pb    push_back
#define  mp    make_pair
using namespace std;
int h,r,ans;
int main(){
    cin>>r>>h;
    int k=h%r;
    double hh=h,rr=r,kk=k;
    if(h<r){
        if(hh-rr+rr>=sqrt(3)*rr)cout<<3<<endl;
        else if(h>=r/2)printf("2\n");
        else printf("1\n");
        return 0;
    }
    kk-=rr;
    if((kk+rr)>=sqrt(3)*rr)
        ans=2*(h/r)+3;
    else if(kk>=0.0)ans=2*(h/r)+2;
    else ans=2*(h/r)+1;
    printf("%d\n",ans);

}

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <string.h>

#define FOR(i,a,b) for(int i=a,_b=b;i<=_b;i++)
#define FO(i,a,b) for(int i=a,_b=b;i<_b;i++)
#define FORD(i,a,b) for(int i=a,_b=b;i>=_b;i--)
#define FOD(i,a,b) for(int i=a,_b=b;i>_b;i--)
#define LL long long

using namespace std;

LL r, h;

void input(){
    cin>>r>>h;
}

void process(){
    LL ans = 0;
    ans += (h/r)*(LL)2;
    if (h%r > (LL)((double)sin(3.14/6.0)*(double)r)) ans += 2;
        else ans++;
    cout<<ans;
}

int main(){
    //freopen("test.in", "r", stdin);
    //freopen("test.out", "w", stdout);
    input();
    process();
    return 0;
}

#include <bits/stdc++.h>

using namespace std;

#define X first
#define Y second
#define INPUT freopen("C.inp","r",stdin)
#define OUTPUT freopen("C.out","w",stdout)
#define FOR(i,l,r) for(auto i=l;i<=r;i++)
#define REP(i,l,r) for(auto i=l;i<r;i++)
#define FORD(i,l,r) for(auto i=l;i>=r;i--)
#define REPD(i,l,r) for(auto i=l;i>r;i--)
#define ENDL printf("\n")
#define debug 1

typedef long long ll;
typedef pair<int,int> ii;

const int inf=1e9;
const int MOD=1e9+7;
const int N=0;

int main(){
    int r,h;
    cin>>r>>h;
    int ans=max((3LL*r*r<=4LL*h*h)?3+(int(h-sqrt(3)*r)/r)*2:1,(2*h>=r)?2+(2*h-r)/r:0);
    cout<<ans;
}

#include <stdio.h>
int main()
{
	int i,sum,x,temp;
	int r,h;
	while(scanf("%d",&r)!=EOF&&scanf("%d",&h)!=EOF)
	{
		temp=h/r;
		if(h-temp*r>=r/2.0)
			temp=temp*2+2;
		else
			temp=temp*2+1;
		printf("%d\n",temp);
	}
	return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cmath>
using namespace std;

int main(void)
{
	long long int r, h;
	cin >> r >> h;
	if (h % r == 0)
		cout << 2*(h / r) + 1;
	else
	{
		cout << 2*(h / r) + 2;
	}
	return 0;
}

#include <iostream>
#include <math.h>

using namespace std;

int main() {
  long double r,h,x,n;
  cin >> r >> h;
  n = (h - r/2)/r;
  x = (h - r + (sqrt(3)*r/4))/r;
  x = 2*(int)x + 3;
  if(n<0) n=0;
  else n = 2*(int)n + 2;
  if(n>x) cout<<x<<endl;
  else cout<<n<<endl;
	return 0;
}

#pragma comment(linker, "/STACK:16777216")
#include <iostream>
#include <cstdio>
#include <stdio.h>
#include <cstdlib>
#include <stdlib.h>
#include <string>
//#include <string.h>
#include <list>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <map>
#include <vector>
#include <iomanip>
#include <queue>
#include <deque>
#include <set>
#include <stack>

//#include <sstream>
//#include "Biginteger.cpp"
//#include "sqrt.cpp"
//#include "tree.cpp"
//#include "funcs.cpp"

#define ll long long
#define ALL(x)           (x).begin(), (x).end()
#define forn(N)          for(ll i = 0; i<N; i++)
#define fornj(N)         for(ll j = 0; j<N; j++)
#define fornk(N)         for(ll k = 0; k<N; k++)
#define PI 3.1415926535897932384626433
#define INF 2147483647
//#define MOD 1000007
#define File "paint"
using namespace std;

int main()
{
	#ifndef ONLINE_JUDGE
	freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
	#else
	//freopen(File".in", "r", stdin); freopen(File".out", "w", stdout);
	#endif

	ll r,h; cin>>r>>h;

	int ans=2*(h/r), n=h%r;

	if (2*n < r)
		cout<<ans+1;
	else if (n<r*2.0*(sqrt(3.)-1))
		cout<<ans+2;
	else
		cout<<ans+3;

	//printf("\n\ntime-%.3lf", clock()*1e-3);
	return 0;
}

//#define ONLINE_JUDGE

#if defined(ONLINE_JUDGE)
#define _SECURE_SCL 0
#endif

#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>
#include <algorithm>
#include <vector>
#include <deque>
#include <set>
#include <map>
#include <functional>
#include <cmath>
#include <climits>
#include <numeric>
#include <memory.h>

#if !defined(__GNUC__)
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef signed short int16_t;
typedef unsigned short uint16_t;
typedef signed long int32_t;
typedef unsigned long uint32_t;
typedef signed long long int64_t;
typedef unsigned long long uint64_t;
#else // !defined(__GNUC__)
#define _CrtDbgBreak()
#endif // !defined(__GNUC__)

#if defined(ONLINE_JUDGE)
#define LOCAL_TEST 0
#else
#define LOCAL_TEST 1
#endif

#if LOCAL_TEST
#define LOCAL_ASSERT(expr) { if (!(expr)) {std::cout << "ASSERT FAILED: '" << #expr << "'" << std::endl; _CrtDbgBreak(); } }
#else
#define LOCAL_ASSERT(expr)
#endif

typedef long double double_t;
typedef std::string string8_t;

typedef std::vector<size_t> vector_size_t;
typedef std::vector<uint64_t> vector_uint64_t;
typedef std::vector<int32_t> vector_int32_t;
typedef std::vector<vector_size_t> vector_2d_size_t;
typedef std::vector<string8_t> vector_string8_t;
typedef std::set<size_t> set_size_t;
typedef std::multiset<string8_t> multiset_string8_t;

// Auxiliary functions definition
//
template<typename T> inline T Abs(const T a) { return a < 0 ? -a : a; }
template<typename T> inline T Min(const T a, const T b) {return a < b ? a : b;}
template<typename T> inline T Max(const T a, const T b) {return a > b ? a : b;}
template<typename T> inline void UpdateMin(T& a, const T b) {a = Min(a, b);}
template<typename T> inline void UpdateMax(T& a, const T b) {a = Max(a, b);}

static const double_t eps = 1.0e-09;
template<typename T> inline bool IsEqual(const T a, const T b) { return Abs(a - b) < eps; }
template<typename T> inline bool IsGreater(const T a, const T b) { return a > b + eps; }
template<typename T> inline bool IsLess(const T a, const T b) { return a + eps < b; }

const double_t BaseD = sqrt(3.0) * 0.5;

int32_t GetCountForStartPos(int32_t firstLineCount, const double_t r, const double_t startPos, const double_t totalLength)
{
    if (IsGreater(startPos + r, totalLength))
    {
        return 0;
    }

    const double_t firstTwoLines = r * (1.0 + BaseD);

    if (IsGreater(startPos + firstTwoLines, totalLength))
    {
        return firstLineCount;
    }

    const double_t remLength = totalLength - startPos - firstTwoLines;
    const double_t remCountF = remLength / r;
    const int32_t remCount = (int32_t)(floor(remCountF));

    const int32_t ans = remCount * 2 + 3;
    return ans;
}

bool Solve(std::istream& ist, std::ostream& ost, const bool multipleTestMode)
{
    //
    double_t r, h;
    ist >> r >> h;

    if (multipleTestMode && !ist)
        return false;

    //
    const int32_t ans1 = GetCountForStartPos(1, r, 0.0, r + h);
    const int32_t ans2 = GetCountForStartPos(2, r, r * 0.5, r + h);
    int32_t ans = 0;
    UpdateMax(ans, ans1);
    UpdateMax(ans, ans2);

    ost << ans << std::endl;

    return multipleTestMode;
}

int main()
{
    std::ios_base::sync_with_stdio(false);
    std::istream& ist = std::cin;
    std::ostream& ost = std::cout;
#if defined(ONLINE_JUDGE)
    Solve(ist, ost, false);
#else
    while(Solve(ist, ost, true)) {};
#endif
}

#include<bits/stdc++.h>
using namespace std;

#define MAX 100005
#define pb push_back
#define MOD 1000000007
typedef long long ll;

int  main(){

    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    #endif

    int R,h; cin >> R >> h;
    long double r = R/2;

    ll nb = max(0,2*((h/R)-1)) ;

    ll res = nb + 2*(2*h-R >= 0);
    int mod = h%R;

    if(h+r-mod >= R)
        res++;

    cout << res;
}

#include<iostream>
#include<cmath>
#include<cstdio>
using namespace std;
int main()
{//freopen("in.txt","r",stdin);
    int r,h;
    while(cin>>r>>h)
    {
        int ans=0;
        int x=r-(h-(h/r)*r);
        //cout<<double(sqrt(3)-1)*r;
        if(h*1.0>=r/2.0)
        {
            if((double(x)<double(r/2.0-sqrt(3)-1)*r)&&x>=0)
            {
                ans+=1;
                if(x==0)
                    ans+=(h/r)*2;
                else
                    ans+=(h/r+1)*2;
            }
            else if(x<=r/2.0)
            {
                ans+=(h/r+1)*2;
            }
            else
                ans+=(h/r)*2+1;
        }

        else
        {
            ans=1;
        }
        cout<<ans<<endl;
    }
    return 0;
}

#include<iostream>
#include<cmath>
using namespace std;
long long r,h,l;
int main()
{
	cin>>r>>h;
	l=h/r;
	if(h-l*r>=r/2) l++;
	if(sqrt((r/2)*(r/2)+(h+r-l*r)*(h+r-l*r))>=r) cout<<l*2+1<<"\n";
	else cout<<l*2<<"\n";
	return 0;
}

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
int h,r;
int ans=0;
int main(){
   scanf("%d%d",&r,&h);
   ans+=h/r;
   h-=ans*r;
   ans*=2;
   if(2*h>=r)ans+=2;
   else{
     double len=sqrt(3)*r/2.0;
    // cout<<"error:"<<len<<" "<<(double)(h+r)-len<<endl;
     if((double)(h+r)-len>0)ans+=1;
   }
   cout<<ans;
}

/**
 *   author:  ks3rr
 *   created: shiva.shiva.shiva krishna:krishna:krishna
 *   Jai Shree Radha Krishna!
**/
#include "bits/stdc++.h"
using namespace std;
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
//typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
#define fio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
typedef long long ll;
typedef long double ld;
ld pi = 3.141592653589793238;
#define nl cout << "\n";
#define pll pair<ll, ll>
#define eb emplace_back
#define pb push_back
#define xINF 2000000000
const ll INF = ll(2e18);
#define xmod 1000000007
#define xmod2 998244353
#ifndef ONLINE_JUDGE
  #define xd(x) cout << #x << " = " << x << "\n";
#else
  #define xd(x) 5;
#endif
ll mo(const ll input, const ll ceil)
{
  return input >= ceil ? input % ceil : input;
}

void solve(int tc)
{
  ll r,h;
  cin>>r>>h;
  ll ans=0;
  ans+=(h)/r;
  ans*=2;
  // ans+=1;
  xd(ans)
  ld g1=(((h)%r)+(r/2.0));
  ld g2=r*1.0;
  if(g1>=g2)
  {
    ans+=2;
      ld   h1=(((h)%r));
      ld h2=71.0*r/100.0;
      if(h1>=h2)
      ans+=1;
  }
  else
    ans+=1;
  // xd(ans)
  // ld   h1=(((h)%r)-(r/2.0));
  // ld h2=73.0*r/100.0;
  // if(h1>=h2)
  // ans+=1;
 xd(ans)
  cout<<ans<<"\n";
  // xd((2*h)%r)
  // xd(((2*h)%r)+(r/2))
  // xd(r)

}

signed main()
{
  fio
  int tt = 1;
  //cin>>tt;
  for (int i = 0; i < tt; i++)
  {
    solve(i + 1);
  }
  return 0;
}

#include <iostream>
#include <math.h>

using namespace std;

int main() {
  long double r,h,x;
  cin >> r >> h;
  x=h/r;
  if((x-(int)x)*r >= r/2 + sqrt(3)*r/4) x = 2*(int)x + 3;
  else if((x-(int)x)*r >= r/2) x = 2*(int)x + 222222;
  else x = 2*(int)x + 1;
  cout<<x<<endl;
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <map>
#include <vector>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;

#define MAX_LEN 100005
#define ll long long
#define mod 100000007

#define MEM(a,al) memset(a,al,sizeof(a))
#define sfx(x) scanf("%lf",&x)
#define sfxy(x,y) scanf("%lf%lf",&x,&y)
#define sdx(x) scanf("%d",&x)
#define sdxy(x,y) scanf("%d%d",&x,&y)
#define pfx(x) printf("%.0f\n",x)
#define pfxy(x,y) printf("%.6f %.6f\n",x,y)
#define pdx(x) printf("%d\n",x)
#define pdxy(x,y) printf("%d %d\n",x,y)
#define getArray(a,len) for(int ia = 0; ia < len; ia++) scanf("%d",&a[ia])
#define printArray(a,len) for(int ia = 0; ia < len; ia++) printf("%d%c",a[ia],(ia==len-1)?'\n':' ')
#define fora(i,n) for(i = 0; i < n; i++)
#define fora1(i,n) for(i = 1; i <= n; i++)
#define foraf(i,n) for(int i = 0; i < n; i++)
#define foraf1(i,n) for(int i = 1; i <= n; i++)
#define ford(i,n) for(i = n-1; i >= 0; i--)
#define ford1(i,n) for(i = n; i > 0; i--)
#define fordf(i,n) for(int i = n-1; i >= 0; i--)
#define fordf1(i,n) for(int i = n; i > 0; i--)

class WriteInfo{
public:
	void info() { printf("[Info] "); }
	void infoEnd() { printf(" [/Info]\n"); }
} W;

const int INF = 1<<29;
const double INFD = 1e20;
const double eps =  1e-6;

int n,m;
double r, h;
double half = 0.5;
double sr3 = sqrt(3);

int main() {
	int i,j,k;
	int T;

	sfxy(r,h);
	if (h < r * half) pdx(1);
	else if (h < half * sr3 * r) pdx(2);
	else{
		int res = 3;
		h -= half * sr3 * r;
		int co = h / r;
		res +=  co * 2;
		h -= co * r;
		if (h >= (sr3 - 1) / 2 * r)
			res++;
		pdx(res);
	}

	return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main(){
    ios_base::sync_with_stdio(false);
    int h,r;
    cin>>r>>h;
        int ans = 2*(h-h%r)/r;
        if(h%r<=r/2+r%2&&h%r>0) ans+=2;
        else ans+=1;
        cout<<ans;
    return 0;
}

#include <iostream>
#include <math.h>

using namespace std;

int main() {
  long r,h;
  cin >> r >> h;
  long a = 1 + (h/r)*2;
  long b = 2 + (int)(h/r - 0.5)*2;
  if(a>b) cout<<a<<endl;
  else cout<<b<<endl;
	return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main(){
    ios_base::sync_with_stdio(false);
    int h,r;
    cin>>r>>h;
    if(h>=r) cout<<2*(h-h%r)/r+1;
    else cout<<"2";
    return 0;
}

#include<iostream>
#include <cmath>
main()
{
int h,r;
std::cin>>r>>h;
std::cout<<std::max( 2*((h*2+r)/(2*r)) , 1+2*(int)( 2*h+r*(2-sqrt(3)) )/(2*r) );
}

#include <stdio.h>
int main()
{
	int i,j,sum,x;
	float r,h;
	for(j=0;j<10000;j++)
	{
		sum=0;
		scanf("%f %f",&r,&h);
		x=h/r;
		for(i=0;i<x;i++)
		{
			sum+=2;
			h-=r;
		}
		if(h>=r/2)
			sum+=2;
		else
			sum+=1;
		printf("%d\n",sum);
	}
	return 0;
}

#include<stdio.h>
main()
{
    unsigned int r , h;
    double ans;
    scanf("%u", &r);
    scanf("%u", &h);
    double k = (2*h)/r;
    ans = k + 1;
    printf("%d", ans);
}

#include <iostream>
using namespace std;

main()
{
      float r, h, mod; int ans = 0;

      cin >> r >> h;

      ans += (int)h / (int)r * 2;

      mod = (int)h % (int)r;

      if (mod >= r / 2)
         ans += 2;
      else
         ans++;
      if (mod >= r / 8 * 7)
         ans++;
cout << ans ;
cin >> r;
return 0;
}

#include <bits/stdc++.h>

using namespace std;

constexpr int N = 1e6 + 10;
constexpr int MOD = 1e9 + 7;

long long r, h, ans;

int main() {
    ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin >> r >> h;
    ans = h / r;
    ans *= 2;
    if (h < r)
        ans = 2;
    if (h % r == 0)
        ans++;
    cout << ans << '\n';
    return 0;
}

#include <string.h>
#include <stdio.h>
#include<math.h>
int main()
{
    double r,h,ll=sqrt(3)/2.,l;
    int s,k;
    while(scanf("%lf%lf",&r,&h)!=EOF)
    {
        s=2*(h/r);
        l=h-(h*0.1)/r*10*r;
        if(l<r/2.)
            s++;
        else if(l<ll*r)
            s=s+2;
        else
            s=s+3;
        printf("%d\n",s);
    }
    return 0;
}

#include <iostream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <vector>
#include <queue>
#include <map>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <memory.h>

using namespace std ;

#define mp make_pair
#define pb push_back
#define all(n) (n).begin(),(n).end()
#define FOR( a , b ) for( int i=a ; i<b ; i++ )
#define SZ size()
#define F first
#define S second
#define LL long long
#define inf 1000000000

using namespace std ;
//contest problem C

int main(){
    //freopen( "in.txt" , "rt" , stdin ) ;
    //freopen( "out.txt" , "wt" , stdout ) ;
    float r , h ;
    int res=0 ;
    cin >> r >> h ;
    res+=(2*(h/r)) , h-=(h/r) ;
    if( (r/2)<=h )
        res+=2 ;
    else
        res++ ;
    cout << res << endl ;
    return 0 ;
}

#include<iostream>

using namespace std;

int main()
{
    long long r, h;
    cin >> r >> h;
    r *= 2;
    h *= 2;
    long long n = h / r;
    long long rem = h % r;
    long long max = 0;
    if(rem >= r / 2)
        max = n * 2 + 2;
    else
        max = n * 2 + 1;
    cout << max << endl;
}

#include <bits/stdc++.h>

#define large long long int
#define xlarge unsigned large
#define regpa pair<large,large>

using namespace std;

int main() {
    ios::sync_with_stdio(false);
    large r, h;
    cin >> r >> h;
    if (h % r == 0)
        cout << 2ll * (h / r) + 1ll;
    else
        cout << 2ll * (h / r + 1ll) - (r / 2ll >= (h % r));
    return 0;
}

#include<iostream>
#include<math.h>
using namespace std;
int main()
{
    int r,h;
    cin>>r>>h;
    int ans = 2*(h/r);
    if(h%r >= ceil((double)r/2.0))
    {
        if((double)(h%r + r) >= sqrt(3)*r + (double)r/2.0 )
            ans = ans + 3;
        else
            ans = ans + 2;
    }
    else
        ans++;
    cout<<ans<<endl;
}

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <vector>
#include <set>
#include <map>
#include <cmath>
#include <algorithm>
#include <memory>
#include <queue>

using namespace std;

#define MAX 1000000000
#define MIN INT_MIN
#define FOR(i,a,n) for(int i = a; i < n; ++i)
#define ll long long

int r;

int calc(int h)
{
	if(r == h)
		return 3;
	if(h > r)
	{
		return (h/r) * 2 + calc(h % r);
	}
	if(h < r)
	{
		if(h < (r + 1)/2) return 1;
		else
		{
			if(r >= 9 && (h == r - 1)) return 3;
			else return 2;
		}
	}
}

int main()
{
	int h;
	cin>>r>>h;
	cout<<calc(h)<<endl;
	return 0;
}

#include <cstdio>
#include <string.h>

int r, h;

int main() {
	scanf("%d%d", &r, &h);
	int ans = 0;
	if (h >= r) {
		ans = 2 * h / r;
		int temp = h % r;
		if (temp >= r * 1.0 / 2) {
			ans += 2;
		}
		else {
			ans += 1;
		}
	}
	else {
		if (h >= r * 1.0 / 2) {
			ans = 2;
		}
		else {
			ans = 1;
		}
	}
	printf("%d\n", ans);
	return 0;
}

/**
 *   author:  ks3rr
 *   created: shiva.shiva.shiva krishna:krishna:krishna
 *   Jai Shree Radha Krishna!
**/
#include "bits/stdc++.h"
using namespace std;
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
//typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
#define fio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
typedef long long ll;
typedef long double ld;
ld pi = 3.141592653589793238;
#define nl cout << "\n";
#define pll pair<ll, ll>
#define eb emplace_back
#define pb push_back
#define xINF 2000000000
const ll INF = ll(2e18);
#define xmod 1000000007
#define xmod2 998244353
#ifndef ONLINE_JUDGE
  #define xd(x) cout << #x << " = " << x << "\n";
#else
  #define xd(x) 5;
#endif
ll mo(const ll input, const ll ceil)
{
  return input >= ceil ? input % ceil : input;
}

void solve(int tc)
{
  ll r,h;
  cin>>r>>h;
  ll ans=0;
  ans+=1;
  ans+=(2*h)/r;
  cout<<ans<<"\n";
}

signed main()
{
  fio
  int tt = 1;
  //cin>>tt;
  for (int i = 0; i < tt; i++)
  {
    solve(i + 1);
  }
  return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<functional>
#include<math.h>
#include<assert.h>
#include<stdarg.h>
#include<time.h>
#include<limits.h>
#include<ctype.h>
#include<string>
#include<map>
#include<set>
#include<queue>
#include<algorithm>
#include<vector>
#include<iostream>
#include<sstream>
using namespace std;

// #defines
#define FOR(i,c) for(__typeof((c).begin()) i=(c).begin();i!=(c).end();i++)
#define SZ(x) ((int)(x).size())
#define ALL(x) (x).begin(),(x).end()
#define LPI(i,n) for(int i=0;i<(n);i++)
#define LPI1(i,a,b) for(int i=(a);i<=(b);i++)
#define LPIL(i,x) for(int i=0;x[i];i++)
#define LPD(i,n) for(int i=(n)-1;i>=0;i--)
#define LPD1(i,a,b) for(int i=(a);i>=(b);i--)
#define I(x) scanf("%d",&x)
#define RI(x) int x;I(x)
#define II(x,y) scanf("%d%d",&x,&y)
#define RII(x,y) int x,y;II(x,y)
#define III(x,y,z) scanf("%d%d%d",&x,&y,&z)
#define RIII(x,y,z) int x,y,z;III(x,y,z)
#define RS(x) scanf("%s",x)
#define PI(x) printf("%d\n",x)
#define PIS(x) printf("%d ",x)
#define CASET int ___T,cas=1;scanf("%d ",&___T);while(___T--)
#define CASEN0(n) int cas=1;while(scanf("%d",&n)!=EOF&&n)
#define CASEN(n) int cas=1;while(scanf("%d",&n)!=EOF)
#define MP make_pair
#define PB push_back
#define MS0(x) memset(x,0,sizeof(x))
#define MS1(x) memset(x,-1,sizeof(x))
#define SEP(x) ((x)?'\n':' ')
#define MAX(a,b) (a>b?a:b)
#define MIN(a,b) (a<b?a:b)
#define F first
#define S second
#ifdef ONLINE_JUDGE
#define FILEIO(x) freopen(#x ".in","r",stdin);freopen(#x ".out","w",stdout);
#define FILEIOS freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
#else
#define FILEIO(x) ;
#define FILEIOS ;
#endif
#define INF 1001001001
typedef pair<int,int> PII;
typedef long long LL;
typedef unsigned long long ULL;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int maxn = (int)1e5 + 10;
const int mod = (int)1e9;
double aabs (double a) { return a < 0 ? -a : a; }
int main()
{
    long int r,h;
    cin>>r>>h;
    long ans=floor(h/r)*2;
   // cout<<ans<<endl;
    if(h%r==0)
    {
        ans=ans+1;
    }
    else if(h%r>=(r+1)/2)
    {
        ans=ans+2;
        double d=((double)r*(sqrt(3)-1)+2)/2;
        r=h%r;
        if((double)r>=d)
        ans++;
    }
    else
    {

        ans=ans+1;
    }
    cout<<ans<<endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair <int, int> ii;
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <ii> vii;
typedef vector <vii> vvii;
#define endl '\n'
#define PB push_back
#define MP make_pair
#define OO (1000000000)         // ToDo
#define EPS (1e-9)              // ToDo
#define MOD (1000000007)        // ToDo
#define all(v) ((v).begin()),((v).end())
#define DEBUG(x) cout<< #x <<" = "<<"\""<< (x) <<"\""<<endl
#define FASTIO ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
void read_file(bool outToFile = true){
#ifdef LOCAL_TEST
    freopen("in.in", "rt", stdin);
    if(outToFile)
    freopen("out.out", "wt", stdout);
#endif
}
int r, h;
//
int main()
{
    read_file();
    while(scanf("%d%d", &r, &h)!=EOF)
    {
        h *= 2, r *= 2;

        int c1 = 1 + h/r * 2;

        int c2 = (h + r/2)/r * 2;

        //DEBUG(c2);

        int ans = max(c1, c2);

        printf("%d\n", ans);
    }
}

#include <iostream>
#include <math.h>

using namespace std;

int main()
{
	double r, h;
	int ans1, ans2 = 0;
	scanf("%lf %lf", &r, &h);

	ans1 = (int)(h / r) * 2 + 1;
	if (h >= r / 2)
	{
		double buf = h - r;
		ans2 = 2;
		if (buf > 0)
			ans2 += (int)((buf / r) * 2);
	}

	if (h  - ((int)(h / r)) * r >= r / 2)
		ans1++;

	printf("%d", max(ans1, ans2));

	return 0;
}

#include <iostream>
#include <random>
#include <vector>
#include <algorithm>
#include <set>
#include <cmath>

using namespace std;

typedef long long ll;

int main() {
    double r, h;
    cin >> r >> h;
    double k32 = sqrt(3.)/2*r;
    double k22 = sqrt(2.)/2*r;
    double k12 = r/2.;
    double v = r + h - r - k32;
    if(v > 0) {
        double num = floor(v / k22);
        int result = 3 + 2 * (int) num;
        cout << result << endl;
    }else{
        if(h < r/2){
            cout << 1 << endl;
        }else{
            cout << 2 << endl;
        }
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

long long h, r;

int main() {
  ios_base::sync_with_stdio(0);

  cin >> h >> r;

  long long gmb, fnc;

  gmb = (2 * h + r) / r;
  fnc = 1 + 2 * (h / r) + (h % r + (r / 2.0 - (sqrt(r * r - r * r / 4.0) - r / 2.0)) >= r);

  cout << max(gmb, fnc) << '\n';

  return 0;
}

//#pragma GCC optimize ('O3')
#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<ll,ll> pll;
typedef long double ld;
#define mp make_pair
#define f first
#define s second
#define pb push_back

typedef complex<double> point;
#define dot(a, b) ((conj(a)*(b)).real())
#define cross(a, b) ((conj(a)*(b)).imag())
#define lenSqr(a) (dot(a, a))
#define X real()
#define Y imag()
#define length(a) (hypot((a).X, (a).Y))
#define same(a, b) (lenSqr(vec(a, b)) < EPS)
#define vec(a, b) ((b)-(a))
#define normalize(a) ((a) / length(a))
#define EPS 1e-8
#define polar(r, ang) ((r)*exp(point(0, (ang))))
#define rotate(v, ang) (polar(v, ang))
//const ld L_PI = acos(-1.0L);
const double PI = acos(-1);

const int N = 1e4 + 5;
const int M = 5e5 + 5;
const int OO = 1e9;
const int mod = 1e9 + 7;

int dcmp(double a, double b) {

    if(a-b > EPS) return 1;
    if(b-a > EPS) return -1;
    return 0;

}

double fixedAngle(double angle) {

    return dcmp(angle, 1) == 0 ? 1 : (dcmp(angle, -1) == 0 ? -1 : angle);

}

int h,r;

void init() {

}

int main() {

    ios_base::sync_with_stdio(false);
    cin.tie(0);

//    freopen("input.txt","r",stdin);
//    freopen("output.txt","w",stdout);

    cin >> r >> h;

    cout << 1 + (2 * (h % r) >= r) + 2 * (h / r * r) << '\n';

    return 0;
}

#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
#include<string>
#include<vector>
#include<iostream>
#include<ctime>
#include<cstdlib>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define PI acos(-1)
#define LL long long
#define inf (1<<30)
#define modn 1000000007
#define maxn 1000+10
#define Mod 2
#define type 1
#define rep(i,a,b) for(i=a;i<=b;i++)
#define eps 1e-7
#define zero(x) fabs(x)<eps
#define equal(x,y) zero(x-y)
#define shift(x) (1<<x)
#define lowbit(x) (x&(-x))
#define del(S,i,j) (S^(1<<i)^(1<<j))
#define jiao(S,i) (S&(1<<i))
#define bing(S,i) (S|(1<<i))
#define bu(S,i) (S^(1<<i))
#define ALL_BITS (1<<n)-1
#define BuJi(A) ALL_BITS^A
#define wei_del(A,bit) (A|=(1<<bit))
#define rep_all for(s=1;s<=ALL_BITS;s++)
#define rep_zi for(s0=s;s0;s0=(s0-1)&s)
using namespace std;
int main()
{
    int r,h,ans;
    scanf("%d%d",&r,&h);
    if(r<=h)
    ans=h/r*2+1;
    else
    {
        if(h>=r/2)
        ans=2;
        else ans=1;
    }
    printf("%d\n",ans);
}

#include<bits/stdc++.h>

using namespace std;

int main()

{

	int r,h,ans=0;

	scanf("%d%d",&r,&h);

	ans+=2*h/r+1;

	h%=r;

	if(2*h>r) ans++;

	if(h>(float)sqrt(3)/2*r) ans++;

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

	return 0;

}

#include <algorithm>
#include <numeric>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <iostream>
#include <iterator>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <sstream>
#include <utility>
#include <functional>
#include <bitset>

using namespace std;

typedef long long ll;
typedef vector<int> VI;
typedef vector<vector<int> > VVI;
typedef pair<int, int> pii;

#define FOR(i, x, y) for(ll i=x; i<=y; i++)
#define FORD(i, x, y) for (ll i = x; i >= y; --i)
#define REP(i, n) for(ll i=0; i<n; i++)
#define REPD(i, n) for(ll i = n - 1; i >= 0; --i)

#define ALL(c) (c).begin(), (c).end()
#define SORT(c) sort(ALL(c))
#define UNIQ(c) SORT(c),(c).resize(unique(ALL(c))-(c).begin())
#define SZ(c) (int)(c).size()

#define CLEAR(x) memset(x,0,sizeof x)
#define FILL(x, v) memset(x,v,sizeof x)
#define COPY(from, to) memcpy(to, from, sizeof to)

#define pb push_back
#define mp make_pair
#define X first
#define Y second

const double eps = 1.0e-7;
const double pi = acos(-1.0);

int main() {
    double r, h;
    cin >> r >> h;
    h /= r;
    double a = sqrt(3.0) / 2;
    int res = 2 * int(h + a);
    if (res / 2 + a <= h + 1.0) cout << res + 1 << endl;
    else cout << res << endl;
    return 0;
}

#include <cstdio>
#include <string.h>
#include <cmath>
#include <iostream>

using namespace std;

long long r, h;

int main() {
	cin >> r >> h;
	long long ans = 2 * (h / r);
	long long temp = h % r;
	if (temp > ((r * 1.0) / 2)) {
		ans += 2;
	}
	else {
		ans += 1;
	}
	cout << ans << endl;
	return 0;
}

/***************************************
    codeforces = topcoder = sahedsohel
    IIT,Jahangirnagar University(42)
****************************************/
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <iterator>
#include <utility>
using namespace std;

#define ll long long int
#define ull unsigned long long int
#define inf INT_MAX
#define linf LLONG_MAX
#define sc(a) scanf("%d",&a)
#define sc2(a,b) scanf("%d%d",&a,&b)
#define sc3(a,b,c) scanf("%d%d%d",&a,&b,&c)
#define sc4(a,b,c,d) scanf("%d%d%d%d",&a,&b,&c,&d)
#define fl(c,i,n) for(i=c;i<n;i++)
#define f(i,n) for(i=0;i<n;i++)
#define mem(a) memset(a,0,sizeof(a))
#define memn(a) memset(a,-1,sizeof(a))
#define pb push_back
#define pp pop_back()
#define aov(a) a.begin(),a.end()
#define mpr make_pair
#define nl printf("\n")
#define PI 2.0*acos(0.0) //#define PI acos(-1.0)
#define xx first
#define yy second
#define mxv(a) *max_element(aov(a))
#define mnv(a) *min_element(aov(a))
#define LB(a,x) (lower_bound(aov(a),x)-a.begin())
#define UB(a,x) (upper_bound(aov(a),x)-a.begin())
#define to_c_string(a) a.c_str()
#define strtoint(c) atoi(&c[0])
#define pii pair< int , int >
#define pcs(a) printf("Case %d: ",a)
#define dbg(x) cout<<#x<<" : "<<x<<endl

template <class T> inline T bigmod(T p,T e,T M){ll ret = 1;for(; e > 0; e >>= 1){if(e & 1) ret = (ret * p) % M;p = (p * p) % M;}return (T)ret;}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}   // M is prime}
template <class T> inline T bpow(T p,T e){ll ret = 1;for(; e > 0; e >>= 1){if(e & 1) ret = (ret * p);p = (p * p);}return (T)ret;}

int toInt(string s){int sm;stringstream ss(s);ss>>sm;return sm;}
int toLlint(string s){long long int sm;stringstream ss(s);ss>>sm;return sm;}

///int month[]={-1,31,28,31,30,31,30,31,31,30,31,30,31};  //Not Leap Year
///int dx[]={1,0,-1,0};int dy[]={0,1,0,-1}; //4 Direction
///int dx[]={1,1,0,-1,-1,-1,0,1};int dy[]={0,1,1,1,0,-1,-1,-1};//8 direction
///int dx[]={2,1,-1,-2,-2,-1,1,2};int dy[]={1,2,2,1,-1,-2,-2,-1};//Knight Direction
///int dx[]={-1,-1,+0,+1,+1,+0};int dy[]={-1,+1,+2,+1,-1,-2}; //Hexagonal Direction
///const double eps=1e-6;

/*****************************************************************/
///////////////////////   GET SET GO    ///////////////////////////
/*****************************************************************/

#define M 100005
#define MD 1000000007LL

int main()
{
    int cs=1,t,i,j,k,h,r;
    double rs;
    while(cin>>r>>h){

        rs=h*1.0+(r*1.0)/2.0;
        i=floor(rs/(r*1.0));
        rs+=(r*1.0)/2.0;
        rs-=i*r*1.0;
//        cout<<rs<<endl;
        i*=2;
        if(rs>=(r/8.00)*7.0)
            i++;
        cout<<i<<endl;
    }

    return 0;
}

#include<iostream>
#include<cmath>
using namespace std;
int main()
{
	int h,r,a,b;
	cin>>r>>h;
	b=1+((((1-(sqrt(3.0)/2))*r+h)/2)*2);
	a=((float(r/2.0)+h)/r)*2;
	cout<<max(a,b);
	return 0;
}

#include <cstdio>
#include <string.h>
#include <cmath>

int r, h;

int main() {
	scanf("%d%d", &r, &h);
	int ans = 0;
	ans = 2 * (h / r);
	h = h % r;
	double temp = sqrt(3.0) * r / 2;
	if (temp <= (r * 1.0 / 2) + h) {
		ans += 3;
	}
	else if (h >= (r * 1.0 / 2)) {
		ans += 2;
	}
	else {
		ans += 1;
	}
	printf("%d\n", ans);
	return 0;
}

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <vector>
#include <set>
#include <map>
#include <cassert>
#include <ctime>
#include <string>

using namespace std;

#ifdef _WIN32
#define LLD "%I64d"
#else
#define LLD "%lld"
#endif

typedef long double ld;

long long rdtsc() {
  long long tmp;
  asm("rdtsc" : "=A"(tmp));
  return tmp;
}

inline int myrand() {
  return abs((rand() << 15) ^ rand());
}

inline int rnd(int x) {
  return myrand() % x;
}

#define pb push_back
#define mp make_pair
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#define sz(x) ((int)(x).size())
#define TASKNAME "text"

const int INF = (int)1e9 + 1;
const ld EPS = 1e-9;

bool solve() {
  int r, h;
  if (scanf("%d%d", &r, &h) < 2) {
    return 0;
  }
  r *= 2, h *= 2;
  int res = ((h - (r / 2)) / r);
  if ((long long) (h - res * r) * (h - res * r) >= 3ll * (r / 2) * (r / 2)) {
    res = (res + 1) * 2 + 1;
  } else {
    res = (res + 1) * 2;
  }
  printf("%d\n", res);

  return 1;
}

int main() {
  srand(rdtsc());
#ifdef DEBUG
  freopen(TASKNAME".out", "w", stdout);
  assert(freopen(TASKNAME".in", "r", stdin));
#endif

  while (1) {
    if (!solve()) {
      break;
    }
#ifdef DEBUG
    eprintf("%.18lf\n", (double)clock() / CLOCKS_PER_SEC);
#endif
  }
  return 0;
}

#include <bits/stdc++.h>

using namespace std;

double r, h;

int main()
{
	cin >> r >> h;
	cout << (int)((h / r) * 2 + 1);
	return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
#pragma comment(linker, "/STACK:16777216")
#define ll long long
using namespace std;
int main() {
	double r,h,bot,up;
	cin>>r>>h;
	bot=(int(h)/int(r))*2;
	up=int(h)%int(r);
	if (up>=sqrt(3.0)/2*r){ cout<<bot+3; return 0; }
	if (up>=r/2) cout<<bot+2;
	else cout<<bot+1;
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int main(){
    float n,r;cin>>r>>n;
    float ans=0;
    ans = ((2*n +r)/r);

    cout << floor(ans+0.5) ;

}

#include <bits/stdc++.h>

using namespace std;

const double eps = 1e-12;

int main() {
  long long R, h;
  scanf("%I64d %I64d", &R, &h);
  long long ans = h / R * 2;
  long long H = h / R * R;
  if(2 * H <= 2 * h - R) {
    ans += 2;
  } else {
    ans++;
  }
  cout << ans << endl;
  return 0;
}