A girl named Xenia has a cupboard that looks like an arc from ahead. The arc is made of a semicircle with radius r (the cupboard's top) and two walls of height h (the cupboard's sides). The cupboard's depth is r, that is, it looks like a rectangle with base r and height h + r from the sides. The figure below shows what the cupboard looks like (the front view is on the left, the side view is on the right).  Xenia got lots of balloons for her birthday. The girl hates the mess, so she wants to store the balloons in the cupboard. Luckily, each balloon is a sphere with radius . Help Xenia calculate the maximum number of balloons she can put in her cupboard. You can say that a balloon is in the cupboard if you can't see any part of the balloon on the left or right view. The balloons in the cupboard can touch each other. It is not allowed to squeeze the balloons or deform them in any way. You can assume that the cupboard's walls are negligibly thin.

The single line contains two integers r, h (1 ≤ r, h ≤ 107).

Print a single integer — the maximum number of balloons Xenia can put in the cupboard.

#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 <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>
#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 <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;
#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 <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 <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 <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<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 <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>
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 <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<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;
}

//#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 <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 <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 <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 <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 <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>
#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;
    }

}

#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;
}

#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>
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

#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<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 <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<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 <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();
    }
}

//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;
}

    #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<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;
}

#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>
#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<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<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 <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 <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;
}

#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 <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 <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<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;
}

#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 <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 <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;
}

#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 <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>
#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 <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;
}

#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 <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 <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 <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<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>
#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 <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;
}

#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 <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<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 <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 <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>
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<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 <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 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<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 <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 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 <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<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;
}

// 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>
#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 <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 <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 <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;
}

#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 <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<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;
}

//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<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>
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;
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;
}

// 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;
}

/*************************************************************************
    > 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;
}

#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 <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<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<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;
}

/*
 * 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;
}

#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;
}

#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>
#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 <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;
}