import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {

    static StringTokenizer st;
    static BufferedReader br;
    static PrintWriter pw;
    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int r = nextInt();
        int h = nextInt();
        int cnt = h / r;
        int ans = cnt*2;
        h -= cnt*r;
        if (2*h >= r) {
            ans += 2;
            if (3l*r*r <= 4l*h*h)
                ans++;
        }
        else
            ans++;
        System.out.println(ans);
    }
    private static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }
    private static long nextLong() throws IOException {
        return Long.parseLong(next());
    }
    private static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
    private static String next() throws IOException {
        while (st==null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }
}

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;

/*
br = new BufferedReader(new FileReader("input.txt"));
pw = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
br = new BufferedReader(new InputStreamReader(System.in));
pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
 */

public class Main {
  private static BufferedReader br;
  private static StringTokenizer st;
  private static PrintWriter pw;

  static String[] list;

  static int[] dx = new int[]{-1,1,0,0};
  static int[] dy = new int[]{0,0,-1,1};

  static char[][] grid;

  public static void main(String[] args) throws IOException {
    br = new BufferedReader(new InputStreamReader(System.in));
    pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    //int qq = 1;
    int qq = Integer.MAX_VALUE;
    //int qq = readInt();
    for(int casenum = 1; casenum <= qq; casenum++)  {
      int r = readInt();
      int h = readInt();
      double height = h + r / 2.0;
      int numCircles = (int)(height/r);
      if(numCircles * r + r * Math.sqrt(3) / 2 <= r+h) {
        numCircles *= 2;
        numCircles++;
      }
      else {
        numCircles *= 2;
      }
      pw.println(numCircles);
    }
    pw.close();
  }

  private static void exitImmediately() {
    pw.close();
    System.exit(0);
  }

  private static long readLong() throws IOException {
    return Long.parseLong(nextToken());
  }

  private static double readDouble() throws IOException {
    return Double.parseDouble(nextToken());
  }

  private static int readInt() throws IOException {
    return Integer.parseInt(nextToken());
  }

  private static String nextToken() throws IOException  {
    while(st == null || !st.hasMoreTokens())  {
      if(!br.ready()) {
        exitImmediately();
      }
      st = new StringTokenizer(br.readLine().trim());
    }
    return st.nextToken();
  }
}

import java.util.*;
import java.io.*;

public class Main{

    BufferedReader in;
    StringTokenizer str = null;
    PrintWriter out;

    private String next() throws Exception{
    	if (str == null || !str.hasMoreElements())
    	    str = new StringTokenizer(in.readLine());
    	return str.nextToken();
    }

    private int nextInt() throws Exception{
	   return Integer.parseInt(next());
    }

    private double nextDouble() throws Exception {
        return Double.parseDouble(next());
    }

    public void run() throws Exception{
    	in = new BufferedReader(new InputStreamReader(System.in));
    	out = new PrintWriter(System.out);

        double R = nextDouble();
        double h = nextDouble();

        int ret = Math.max(firstMethod(R, h), secondMethod(R, h));

        out.println(ret);
        out.close();
    }

    private int firstMethod(double R, double h) {
        double r = R/2;
        double three = Math.sqrt(3);

        int ret = 1;
        if (h >= r*three) {
            h-=r*three;
            ret+=2;
        }

        int k = (int)(h/R);
        h-=k*R;
        ret+=2*k;

        if (h >= r + r*three/2) {
            ret++;
        }

        return ret;
    }

    private int secondMethod(double R, double h) {
        double r = R/2;
        double three = Math.sqrt(3);

        int ret = 0;
        if (h >= r) {
            ret+=2;
            h-=r;
        }

        int k = (int)(h/R);
        h-=k*R;
        ret+=2*k;

        if (h >= r + r*three/2) {
            ret++;
        }

        return ret;
    }

    public static void main(String args[]) throws Exception{
	   new Main().run();
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class C {
	BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter out;

	public void solve() throws IOException {
		double R = nextDouble();
		double H = nextDouble();

		int ans = (int)((H+R/2) / R) * 2;
		double remain = H + R/2 - ans/2 * R;
		if( remain >= (Math.sqrt(3)-1)/2 * R)
			ans++;
		out.println( ans );
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new C().run();
	}

	public void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            out = new PrintWriter(System.out);
            solve();
            reader.close();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class Main {

	public static void main(String[] args) {
		try {
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			PrintWriter pw = new PrintWriter(System.out);

			String[] param = br.readLine().split(" ");
			int r = Integer.parseInt(param[0]);
			int h = Integer.parseInt(param[1]);
			double d = (double)h / r;

			int answer = 1;
			double r3 = Math.sqrt(3.0);
			for (int i = 1; ; i++) {
				double t = r3*i - r3/2.0;
				if (d<t) break;
				answer = Math.max(answer, i*3 + (int)(d-t)*2);
			}
			for (int i = 0; ; i++) {
				double t = r3*i + 0.5;
				if (d<t) break;
				answer = Math.max(answer, 2+i*3 + (int)(d-t)*2);
			}
			pw.println(answer);

			pw.close();
			br.close();
		} catch (IOException e) {
			e.printStackTrace();
			return;
		}
	}
}

import java.util.Scanner;

public class ce {
	public static void main(String[] args)
	{
		Scanner scan=new Scanner(System.in);
		int r=scan.nextInt();
		int h=scan.nextInt();
		int sum=0;
		sum=2*(h/r);
		h%=r;
		if(h<0.5*r)
			sum++;
		if(h>=0.5*r&&h<Math.sqrt(0.75)*r)
			sum+=2;
		if(h>=Math.sqrt(0.75)*r)
			sum+=3;
		System.out.println(sum);
	}
}

import java.util.*;
public class c {
public static void main(String[] args)
{
    Scanner input = new Scanner(System.in);
    double r = input.nextDouble(), h = input.nextDouble(), topHeight = 0;
    int count = 0;
    while(topHeight + r <= h+r/2)
    {
        topHeight += r;
        count += 2;
    }
    System.out.println((topHeight + r*(Math.sqrt(3))/2 <= h+r) ? count+1 : count);
}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Balloons
{
	public static void main(String[] args) throws IOException
	{
		InputStreamReader a = new InputStreamReader(System.in);
		BufferedReader buf = new BufferedReader(a);
		String[] temp = buf.readLine().split(" ");
		int r=Integer.parseInt(temp[0]);
		int h=Integer.parseInt(temp[1]);
		int out=2*(h/r);
		double left=h*1.0/r-out/2;
		if (left>=Math.sqrt(3.0)/2)
			out+=3;
		else if(left>=0.5)
			out+=2;
		else
			out++;
		System.out.print(out);
	}
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author Trung Pham
 */
public class C {

    public static void main(String[] args) {
        Scanner in = new Scanner();
        PrintWriter out = new PrintWriter(System.out);
        long r = in.nextInt();
        long h = in.nextInt();
        long result = 0;
        double val = r*r - (double)(r*r)/4;
        val = Math.sqrt(val) + r;
        if(h + r >= val){
            result += 3 + 2*(h + r - val)/r;
        }else{
            if(h >=(double)r/2){
                result = 2;
            }else{
                result = 1;
            }
        }
        out.println(result);
        out.close();

    }

    static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        } else {
            return gcd(b, a % b);
        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() {
            //System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}

import java.util.Scanner;

public class INeedAHundredBlackCoffees {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int rInt = sc.nextInt();
		int hInt = sc.nextInt();

		double r = rInt;
		double h = hInt;

		double rootThreeOverTwo = Math.sqrt(3.0) / 2.0;

		int fuckingAnswer = (int) Math.max(
				(((Math.floor((h - (r/2)) / r))*2) + 2 ),
				(((Math.floor((h/r)+(1)-rootThreeOverTwo)*2)+1))
				);

		System.out.println(fuckingAnswer);

	}

}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        try {
            if (new File("input.txt").exists())
                System.setIn(new FileInputStream("input.txt"));
        } catch (SecurityException e) {
        }
        new Main().run();
    }

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st = new StringTokenizer("");

    private void run() throws IOException {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);

        int r = nextInt();
        int h = nextInt();
        int p = h/r;
        p*=2;
        int c = h%r;
        p++;

        double as = (double)r/2;
        int ty = (int)(as+1-0.000001);

        if (c >= ty) p++;

        double as1 = r*sqrt(3);
        as1 = (double)as1/2;

        //System.err.println(as1);

        int ty1 = (int)(as1+1-0.000001);
    //  System.err.println(ty1);

        //ty1*=3;

        if (c >= ty1) p++;

        out.println(p);

        in.close();
        out.close();
    }

    void chk(boolean b) {
        if (b)
            return;
        System.out.println(new Error().getStackTrace()[1]);
        exit(999);
    }
    void deb(String fmt, Object... args) {
        System.out.printf(Locale.US, fmt + "%n", args);
    }
    String nextToken() throws IOException {
        while (!st.hasMoreTokens())
            st = new StringTokenizer(in.readLine());
        return st.nextToken();
    }
    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
    String nextLine() throws IOException {
        st = new StringTokenizer("");
        return in.readLine();
    }
    boolean EOF() throws IOException {
        while (!st.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null)
                return true;
            st = new StringTokenizer(s);
        }
        return false;
    }
}

//package round199;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;

public class C {
	InputStream is;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{
		double r = ni(), h = ni();
		double[][] dp = new double[8][2]; // [last3][lastptn]
		double h12 = Math.sqrt(3)/2 * r;
		int i;
		for(i = 1;;i++){ //
			int ind = i&7;
			int prev = (i+7)&7;
			int pprev = (i+6)&7;
			if(i == 1){
				dp[1][0] = r;
				dp[1][1] = Double.POSITIVE_INFINITY;
			}else if(i == 2){
				dp[2][0] = Double.POSITIVE_INFINITY;
				dp[2][1] = h*2 >= r ? r : Double.POSITIVE_INFINITY;
			}else{
				dp[ind][0] = dp[prev][1] + h12;
				dp[ind][1] = Math.min(dp[pprev][0] + h12, dp[pprev][1] + r);
			}
			if(dp[ind][0] > h+r && dp[ind][1] > h+r)break;
		}
		int max = 0;
		for(int j = 0;j < 8;j++){
			int ind = (i+8-j)&7;
			if(dp[ind][0] <= h+r)max = Math.max(max, i-j);
			if(dp[ind][1] <= h+r/2)max = Math.max(max, i-j);
		}
		out.println(max);
	}

	void run() throws Exception
	{
		is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis()-s+"ms");
	}

	public static void main(String[] args) throws Exception { new C().run(); }

	private byte[] inbuf = new byte[1024];
	private int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if(lenbuf == -1)throw new InputMismatchException();
		if(ptrbuf >= lenbuf){
			ptrbuf = 0;
			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
			if(lenbuf <= 0)return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
	private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

	private double nd() { return Double.parseDouble(ns()); }
	private char nc() { return (char)skip(); }

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while(p < n && !(isSpaceChar(b))){
			buf[p++] = (char)b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for(int i = 0;i < n;i++)map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for(int i = 0;i < n;i++)a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}

import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.Math.*;

public class C {
    void solve() {
        double r = sc.nextDouble();
        double h = sc.nextDouble();
        double k = Math.floor(h/r + 0.5);
        double eps = 1e-6;
        double p = 0.0;
        if (h + r - k*r + eps >= (Math.sqrt(0.75))*r ) {
            p = 1.0;
        }
        out.print((int) (2.0 * k + p) );
    }

    FastScanner sc;
    PrintWriter out;

    public static void main(String[] args) {
        (new C()).run();
    }

    void run() {
        sc = new FastScanner();
        out = new PrintWriter(System.out);
        solve();
        out.flush();
    }

    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(nextToken());
        }

        long nextLong() {
            return Long.parseLong(nextToken());
        }

        double nextDouble() {
            return Double.parseDouble(nextToken());
        }

        String nextStr() {
            return nextToken();
        }
    }
}

import static java.util.Arrays.sort;
import java.util.Scanner;

public class third
{
	public static void main(String arr[])
	{
		Scanner sc= new Scanner(System.in);
		int r = sc.nextInt();
		int h = sc.nextInt();
		int k = 2*(h/r);
		int rem = h%r;
		if((2*rem)<r)k++;
		else if((double)(2*rem)<(Math.sqrt(3)*r))k+=2;
		else k+=3;
		System.out.println(k);
	}
}

import java.util.*;

public class cf342C{

	public static void main(String args[])
	{

		Scanner sc  = new Scanner(System.in);
		int r = sc.nextInt();
		int h = sc.nextInt();
		int total = 0;
		if(h >= r)
		{
			total += 2*(h/r);
			h= h -(h/r)*r;
		}

		if(2*h >= Math.ceil((Math.sqrt(3))*(float)r))
			total += 3;
		else if(2*h >= r)
			total += 2;
		else
			total += 1;

		System.out.println(total);

	}

}

import java.util.Scanner;

public class C {

    public static void main(String[] args) {
        C solver = new C();
        solver.solve();
    }

    private void solve() {
        Scanner sc = new Scanner(System.in);
//        sc = new Scanner("30 58\n");

        int r = sc.nextInt();
        int h = sc.nextInt();

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

        k *= 2;

        if (2 * p >= Math.sqrt(3) * r) {
            k += 3;
        } else if (2 * p >= r) {
            k += 2;
        } else {
            k += 1;
        }

        System.out.println(k);
    }

}

import java.util.Scanner;

public class Cupboard_and_Balloons__342C
{
	public static void main(String ... args) throws Exception
    {
        final double allow = 0.8660254;
        Scanner in = new Scanner(System.in);
        int r = in.nextInt();
        int h = in.nextInt();
        int a = 0;
        int extraspace = h%r;
        //System.out.println("compare " + 2*extraspace + " and " + (r+(double)(r*allow)));
        if(extraspace >= (double)(r*allow)) a= 3;
        else if(2*(extraspace) >= r) a = 2;
        else a = 1;
        if(h>=r/2) a += 2*(int)(h/r);
        System.out.println(a);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Y {

	public static void main(String[] args) throws Exception{
		Scanner sc = new Scanner(System.in);

		long r = sc.nextInt();
		long h = sc.nextInt();

		long rem = h % r ;

		System.out.println( 2*(h/r)+ ( 4*rem*rem>= 3*r*r ? 3 : 2*rem>=r ? 2 : 1) );

	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}

}

import java.io.*;
import java.util.*;

public class C199{

        private BufferedReader in;
        private StringTokenizer st;
        private PrintWriter out;

        void solve() throws IOException{

            int r = nextInt();
            int h = nextInt();
            int ans = h/r * 2;
            h %= r;
            if(h*2.0 >= Math.sqrt(3)*r) ans += 3;
            else if(h*2 < r) ans ++;
            else ans += 2;
            out.println(ans);

        }

        C199() throws IOException {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            eat("");
            solve();
            out.close();
        }

        private void eat(String str) {
            st = new StringTokenizer(str);
        }

        String next() throws IOException {
            while (!st.hasMoreTokens()) {
                String line = in.readLine();
                if (line == null) {
                    return null;
                }
                eat(line);
            }
            return st.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        public static void main(String[] args) throws IOException {
            new C199();
        }

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

}

import com.sun.javafx.geom.Edge;

import java.io.*;
import java.util.*;

public class Main2 {

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

		int r = sc.nextInt() * 2, h = sc.nextInt() * 2;
		int best = 1 + solve(r, h);
		if(h * 2 >= r)
			best = Math.max(best, 2 + solve(r, h - r / 2));
		out.println(best);
		out.flush();
	}

	static int solve(int r, int h)
	{
		int ans = 2 * h / r;
		h %= r;
		if(1l * h * h >= 3l * r * r / 4)
			++ans;
		return ans;
	}

	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {return Integer.parseInt(next());}

		public long nextLong() throws IOException {return Long.parseLong(next());}

		public String nextLine() throws IOException {return br.readLine();}

		public double nextDouble() throws IOException { return Double.parseDouble(next()); }

		public boolean ready() throws IOException {return br.ready();}
	}
}

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Solution {
    private IO io;
    private int ioMode = -1;
    private String problemName = "";
    private final String mjArgument = "master_j";

    public static void main(String programArguments[]) throws IOException{
        if(programArguments != null && programArguments.length > 0)
            new Solution().run(programArguments[0]);
        else
            new Solution().run(null);
    }

    private void run(String programArgument) throws IOException {
        //         _______________________________________________ _________
        //        |   Input Mode     |      Output Mode    | mode | comment |
        //        |------------------|---------------------|----- |---------|
        //        |   input.txt      |      System.out     |  0   |    mj   |
        //        |   System.in      |      System.out     |  1   |  T / CF |
        //        |<problemName>.in  |  <problemName>.out  |  2   |         |
        //        |   input.txt      |      output.txt     |  3   |    C    |
        //        |__________________|_____________________|______|_________|
        long nanoTime = 0;
        if(programArgument != null && programArgument.equals(mjArgument)) // mj
            ioMode = 0;
        else if(System.getProperty("ONLINE_JUDGE") != null) // T / CF
            ioMode = 1;
        else
            ioMode = 2;
        switch(ioMode){
            case -1:
                try{
                    throw new Exception("<ioMode> init failure") ;
                }catch (Exception e){
                    e.printStackTrace();
                }
                return;
            case 0:
                break;
            case 1:
                break;
            case 2:
                if(problemName.length() == 0){
                    try{
                        throw new Exception("<problemName> init failure");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return;
                }
            case 3:
                break;
        }
        io = new IO(ioMode, problemName);
        if(ioMode == 0){
            System.out.println("File output : \n<start>");
            System.out.flush();
            nanoTime = System.nanoTime();
        }
        solve();
        io.flush();
        if(ioMode == 0){
            System.out.println("</start>");
            long t = System.nanoTime() - nanoTime;
            int d3 = 1000000000, d2 = 1000000, d1 = 1000;
            if(t>=d3)
                System.out.println(t/d3 + "." + t%d3 + " seconds");
            else if(t>=d2)
                System.out.println(t/d2 + "." + t%d2 + " millis");
            else if(t>=d1)
                System.out.println(t/d1 + "." + t%d1 + " micros");
            else
                System.out.println(t + " nanos");
            System.out.flush();
        }
    }

    private void solve() throws IOException {
        double r = io.nI(), h = io.nI();
        long ans = 0;
        while(h > r){
            h -= r;
            ans++;
        }
        if(h >= r/2){
            h -= r/2;
            ans++;
        }else
            h += r/2;
        ans *= 2;
        if(dist(r/2, 0, r, h+r/2) >= r)
            ans++;
        io.wln(ans);
    }//2.2250738585072012e-308

    double dist(double y1, double z1, double y2, double z2){
        double d1 = (y1-y2)*(y1-y2);
        double d2 = (z1-z2)*(z1-z2);
        double d = d1 + d2;
        return sqrt(d);
    }

    /**
     * Input-output class
     * @author master_j
     * @version 0.2.5
     */
    @SuppressWarnings("unused")
    private class IO{
        private boolean alwaysFlush;
        StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
        public IO(int ioMode, String problemName) throws IOException{
            Locale.setDefault(Locale.US);
            //         _______________________________________________ _________
            //        |   Input Mode     |      Output Mode    | mode | comment |
            //        |------------------|---------------------|----- |---------|
            //        |   input.txt      |      System.out     |  0   |    mj   |
            //        |   System.in      |      System.out     |  1   |  T / CF |
            //        |<problemName>.in  |  <problemName>.out  |  2   |         |
            //        |   input.txt      |      output.txt     |  3   |    C    |
            //        |__________________|_____________________|______|_________|
            switch(ioMode){
                case 0:
                    reader = new FileReader("input.txt");
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 1:
                    reader = new InputStreamReader(System.in);
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 2:
                    reader = new FileReader(problemName + ".in");
                    writer = new FileWriter(problemName + ".out");
                    break;
                case 3:
                    reader = new FileReader("input.txt");
                    writer = new FileWriter("output.txt");
                    break;
            }
            br = new BufferedReader(reader);
            in = new StreamTokenizer(br);
            out = new PrintWriter(writer);
            alwaysFlush = false;
        }
        public void setAlwaysFlush(boolean arg){alwaysFlush = arg;}
        public void wln(){out.println(); if(alwaysFlush)flush();}
        public void wln(int arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(long arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(double arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(String arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(boolean arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(char arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(float arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(Object arg){out.println(arg); if(alwaysFlush)flush();}
        public void w(int arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(long arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(double arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(String arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(boolean arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(char arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(float arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(Object arg){out.print(arg); if(alwaysFlush)flush();}
        public void wf(String format, Object...args){out.printf(format, args); if(alwaysFlush)flush();}
        public void flush(){out.flush();}
        public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
        public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
        public String nS() throws IOException {in.nextToken(); return in.sval;}
        public double nD() throws IOException {in.nextToken(); return in.nval;}
        public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
        public char nC() throws IOException {return (char)br.read();}
        public void wc(char...arg){for(char c : arg){in.ordinaryChar(c);in.wordChars(c, c);}}
        public void wc(String arg){wc(arg.toCharArray());}
        public void wc(char arg0, char arg1){in.ordinaryChars(arg0, arg1); in.wordChars(arg0, arg1);}
        public boolean eof(){return in.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol(){return in.ttype == StreamTokenizer.TT_EOL;}
    }
}

import java.util.*;
import java.io.*;
import java.math.*;
import java.awt.geom.*;

import static java.lang.Math.*;

public class Solution implements Runnable {

	public void solve() throws Exception {
		long r = sc.nextInt(), h = sc.nextInt();
		r *= 2;
		h *= 2;
		long n = (h + r / 2) / r;
		if (n == 0) {
			out.println(1);
		} else {
			long hmax = n * r - r / 2;
			long left = h + r - hmax;
			long ans = 2 * n;
			if (r * r * 3 <= (left - r / 2) * (left - r / 2) * 4) {
				ans++;
			}
			out.println(ans);
		}
	}

	static Throwable uncaught;

	BufferedReader in;
	FastScanner sc;
	PrintWriter out;

	@Override
	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			sc = new FastScanner(in);
			solve();
		} catch (Throwable uncaught) {
			Solution.uncaught = uncaught;
		} finally {
			out.close();
		}
	}

	public static void main(String[] args) throws Throwable {
		Thread thread = new Thread(null, new Solution(), "", (1 << 26));
		thread.start();
		thread.join();
		if (Solution.uncaught != null) {
			throw Solution.uncaught;
		}
	}

}

class FastScanner {

	BufferedReader in;
	StringTokenizer st;

	public FastScanner(BufferedReader in) {
		this.in = in;
	}

	public String nextToken() throws Exception {
		while (st == null || !st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	public int nextInt() throws Exception {
		return Integer.parseInt(nextToken());
	}

	public long nextLong() throws Exception {
		return Long.parseLong(nextToken());
	}

	public double nextDouble() throws Exception {
		return Double.parseDouble(nextToken());
	}

}

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Solution {
    private IO io;
    private int ioMode = -1;
    private String problemName = "";
    private final String mjArgument = "master_j";

    public static void main(String programArguments[]) throws IOException{
        if(programArguments != null && programArguments.length > 0)
            new Solution().run(programArguments[0]);
        else
            new Solution().run(null);
    }

    private void run(String programArgument) throws IOException {
        //         _______________________________________________ _________
        //        |   Input Mode     |      Output Mode    | mode | comment |
        //        |------------------|---------------------|----- |---------|
        //        |   input.txt      |      System.out     |  0   |    mj   |
        //        |   System.in      |      System.out     |  1   |  T / CF |
        //        |<problemName>.in  |  <problemName>.out  |  2   |         |
        //        |   input.txt      |      output.txt     |  3   |    C    |
        //        |__________________|_____________________|______|_________|
        long nanoTime = 0;
        if(programArgument != null && programArgument.equals(mjArgument)) // mj
            ioMode = 0;
        else if(System.getProperty("ONLINE_JUDGE") != null) // T / CF
            ioMode = 1;
        else
            ioMode = 2;
        switch(ioMode){
            case -1:
                try{
                    throw new Exception("<ioMode> init failure") ;
                }catch (Exception e){
                    e.printStackTrace();
                }
                return;
            case 0:
                break;
            case 1:
                break;
            case 2:
                if(problemName.length() == 0){
                    try{
                        throw new Exception("<problemName> init failure");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return;
                }
            case 3:
                break;
        }
        io = new IO(ioMode, problemName);
        if(ioMode == 0){
            System.out.println("File output : \n<start>");
            System.out.flush();
            nanoTime = System.nanoTime();
        }
        solve();
        io.flush();
        if(ioMode == 0){
            System.out.println("</start>");
            long t = System.nanoTime() - nanoTime;
            int d3 = 1000000000, d2 = 1000000, d1 = 1000;
            if(t>=d3)
                System.out.println(t/d3 + "." + t%d3 + " seconds");
            else if(t>=d2)
                System.out.println(t/d2 + "." + t%d2 + " millis");
            else if(t>=d1)
                System.out.println(t/d1 + "." + t%d1 + " micros");
            else
                System.out.println(t + " nanos");
            System.out.flush();
        }
    }

    private void solve() throws IOException {
        double r = io.nI(), h = io.nI();
        long ans = 0;
        while(h > r){
            h -= r;
            ans++;
        }
        if(h >= r/2){
            h -= r/2;
            ans++;
        }else
            h += r/2;
        ans *= 2;
        if(dist(0, 0, r/2, h+r/2) >= r)
            ans++;
        io.wln(ans);
    }//2.2250738585072012e-308

    double dist(double y1, double z1, double y2, double z2){
        double d1 = (y1-y2)*(y1-y2);
        double d2 = (z1-z2)*(z1-z2);
        double d = d1 + d2;
        return sqrt(d);
    }

    /**
     * Input-output class
     * @author master_j
     * @version 0.2.5
     */
    @SuppressWarnings("unused")
    private class IO{
        private boolean alwaysFlush;
        StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
        public IO(int ioMode, String problemName) throws IOException{
            Locale.setDefault(Locale.US);
            //         _______________________________________________ _________
            //        |   Input Mode     |      Output Mode    | mode | comment |
            //        |------------------|---------------------|----- |---------|
            //        |   input.txt      |      System.out     |  0   |    mj   |
            //        |   System.in      |      System.out     |  1   |  T / CF |
            //        |<problemName>.in  |  <problemName>.out  |  2   |         |
            //        |   input.txt      |      output.txt     |  3   |    C    |
            //        |__________________|_____________________|______|_________|
            switch(ioMode){
                case 0:
                    reader = new FileReader("input.txt");
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 1:
                    reader = new InputStreamReader(System.in);
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 2:
                    reader = new FileReader(problemName + ".in");
                    writer = new FileWriter(problemName + ".out");
                    break;
                case 3:
                    reader = new FileReader("input.txt");
                    writer = new FileWriter("output.txt");
                    break;
            }
            br = new BufferedReader(reader);
            in = new StreamTokenizer(br);
            out = new PrintWriter(writer);
            alwaysFlush = false;
        }
        public void setAlwaysFlush(boolean arg){alwaysFlush = arg;}
        public void wln(){out.println(); if(alwaysFlush)flush();}
        public void wln(int arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(long arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(double arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(String arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(boolean arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(char arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(float arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(Object arg){out.println(arg); if(alwaysFlush)flush();}
        public void w(int arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(long arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(double arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(String arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(boolean arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(char arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(float arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(Object arg){out.print(arg); if(alwaysFlush)flush();}
        public void wf(String format, Object...args){out.printf(format, args); if(alwaysFlush)flush();}
        public void flush(){out.flush();}
        public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
        public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
        public String nS() throws IOException {in.nextToken(); return in.sval;}
        public double nD() throws IOException {in.nextToken(); return in.nval;}
        public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
        public char nC() throws IOException {return (char)br.read();}
        public void wc(char...arg){for(char c : arg){in.ordinaryChar(c);in.wordChars(c, c);}}
        public void wc(String arg){wc(arg.toCharArray());}
        public void wc(char arg0, char arg1){in.ordinaryChars(arg0, arg1); in.wordChars(arg0, arg1);}
        public boolean eof(){return in.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol(){return in.ttype == StreamTokenizer.TT_EOL;}
    }
}

// package CF;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class D {
	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int r = sc.nextInt(), h = sc.nextInt();
		int hi = (int)(Math.sqrt(3)*r/2);

		out.println(h/r*2 + (hi < h%r ? 3: h%r*2 >= r? 2:1));
		out.flush();
		out.close();
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public Scanner(FileReader fileReader) {
			br = new BufferedReader(fileReader);
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public boolean ready() throws IOException {
			return br.ready();
		}
	}
}

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskC {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        long r=in.nextInt();
        long h=in.nextInt();
        if(2*h>=r) {
            // we can organize two rows
            long doubletotalHeight=r+2*h;
            double eps=1e-8;
            int rows=(int)((h*1.0)/r+0.5+eps);
            //can we fit an extra ball?
            int extra=0;
            long x1=2*r;
            long y1=2*h+r;
            long y2=r+(rows-1)*2*r;
            long x2=r;
            if((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)>=4*r*r) {
               extra=1;
            }

            out.println(2*rows+extra);
        }
        else {
            out.println(1);
        }
    }
}

class InputReader {
    StringTokenizer st;
    BufferedReader in;
    public InputReader(InputStream ins)
    {
        in = new BufferedReader(new InputStreamReader(ins));
    }

    public String nextToken()
    {
        while(st==null || !st.hasMoreTokens())
        {
            try {
                st=new StringTokenizer(in.readLine());
            } catch (IOException e) {
                e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
            }
        }
        return st.nextToken();
    }
    public int nextInt()
    {

        return Integer.parseInt(nextToken());
    }

    }

import java.io.*;
import java.util.*;
public class cupboard_balloons
{
	public static void main(String args[])
	{
		InputReader in = new InputReader(System.in);
		OutputStream outputStream = System.out;
		PrintWriter out = new PrintWriter(outputStream);
		/*------------------------------My Code starts here------------------------------*/
		int r=in.nextInt(),h=in.nextInt(),ans=0;
		double d=Math.sqrt(3);
		ans+=(h/r)*2;
		if(r+h%r>=((d+2)*r)/2)
			ans+=3;
		else if(h%r>=r/2.0)
			ans+=2;
		else
			ans+=1;
		out.println(ans);
		out.close();
		/*------------------------------The End------------------------------------------*/
	}
	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader(InputStream inputstream) {
			reader = new BufferedReader(new InputStreamReader(inputstream));
			tokenizer = null;
		}

		public String nextLine(){
			String fullLine=null;
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					fullLine=reader.readLine();
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
				return fullLine;
			}
			return fullLine;
		}
		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}
		public long nextLong() {
			return Long.parseLong(next());
		}
		public int nextInt() {
			return Integer.parseInt(next());
		}
	}
}

import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class Main extends PrintWriter {
    final Random rand = new Random(31);
    final int inf = (int) 1e9;
    final long linf = (long) 1e18;

    final static String IO = "_std";

    double dist(double x1, double y1, double x2, double y2) {
        return sqrt((x1 - x2 ) * (x1 - x2) + (y1 - y2) * (y1 - y2));
    }

    void solve() throws IOException {
        int r = nextInt();
        int h = nextInt();

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

        double d = dist(0, h + r / 2.0, r / 2.0, 1.0 * x * r - r / 2.0);

        if (d > r - 1e-9) {
            println(2 * x + 1);
        } else {
            println(2 * x);
        }
    }

    BufferedReader in;
    StringTokenizer stok;

    Main() {
        super(System.out);
        in = new BufferedReader(new InputStreamReader(System.in));
    }

    Main(String fileIn, String fileOut) throws IOException {
        super(fileOut);
        in = new BufferedReader(new FileReader(fileIn));
    }

    public static void main(String[] args) throws IOException {
        Main main;
        if ("_std".equals(IO)) {
            main = new Main();
        } else if ("_iotxt".equals(IO)) {
            main = new Main("input.txt", "output.txt");
        } else {
            main = new Main(IO + ".in", IO + ".out");
        }
        main.solve();
        main.close();
    }

    String next() throws IOException {
        while (stok == null || !stok.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null) {
                return null;
            }
            stok = new StringTokenizer(s);
        }
        return stok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    int[] nextIntArray(int len) throws IOException {
        int[] a = new int[len];
        for (int i = 0; i < len; i++) {
            a[i] = nextInt();
        }
        return a;
    }

    int[] nextIntArraySorted(int len) throws IOException {
        int[] a = nextIntArray(len);
        shuffle(a);
        Arrays.sort(a);
        return a;
    }

    void shuffle(int[] a) {
        for (int i = 1; i < a.length; i++) {
            int x = rand.nextInt(i + 1);
            int _ = a[i];
            a[i] = a[x];
            a[x] = _;
        }
    }

    void shuffleAndSort(int[] a) {
        shuffle(a);
        Arrays.sort(a);
    }

    boolean nextPermutation(int[] p) {
        for (int a = p.length - 2; a >= 0; --a) {
            if (p[a] < p[a + 1])
                for (int b = p.length - 1; ; --b)
                    if (p[b] > p[a]) {
                        int t = p[a];
                        p[a] = p[b];
                        p[b] = t;
                        for (++a, b = p.length - 1; a < b; ++a, --b) {
                            t = p[a];
                            p[a] = p[b];
                            p[b] = t;
                        }
                        return true;
                    }
        }
        return false;
    }

    <T> List<T>[] createAdjacencyList(int n) {
        List<T>[] res = new List[n];
        for (int i = 0; i < n; i++) {
            res[i] = new ArrayList<>();
        }
        return res;
    }

    void println(Object... a) {
        for (int i = 0; i < a.length; i++) {
            if (i != 0) {
                print(" ");
            }
            print(a[i]);
        }
        println();
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class C {
    public static void main(String[] args) throws Exception {
        InputStreamReader input = new InputStreamReader(System.in);
        BufferedReader read = new BufferedReader(input);

        String[] ss = read.readLine().split(" ");
        int r = Integer.parseInt(ss[0]);
        int h = Integer.parseInt(ss[1]);
        long ret = getCount(r, h);
        System.out.println(""+ret);
    }

    private static long getCount(long r, long h) {
        if (r > h * 2) return 1;
        double height45 = h + Math.sqrt(2) / 2.0 * r;
        //long side = (long) (Math.floor(height45 / (double)r));
        long side = (long) Math.floor((h - r/ 2.0) / (double) r);
        side++;
        long ret = side * 2;
        double lastcenter = side * r - r / 2.0;
        double x = h + r/2.0 - lastcenter;
        double diag = Math.sqrt(x * x + r * r / 4.0);
        if (diag >= r) {
            ret++;
        }
        return ret;
    }
}

import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class Main extends PrintWriter {
    final Random rand = new Random(31);
    final int inf = (int) 1e9;
    final long linf = (long) 1e18;

    final static String IO = "_std";

    double dist(double x1, double y1, double x2, double y2) {
        return sqrt((x1 - x2 ) * (x1 - x2) + (y1 - y2) * (y1 - y2));
    }

    void solve() throws IOException {
        int r = nextInt();
        int h = nextInt();

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

        double d = dist(0, h + r / 2.0, r / 2.0, 1.0 * x * r - r / 2.0);

        if (d >= r) {
            println(2 * x + 1);
        } else {
            println(2 * x);
        }
    }

    BufferedReader in;
    StringTokenizer stok;

    Main() {
        super(System.out);
        in = new BufferedReader(new InputStreamReader(System.in));
    }

    Main(String fileIn, String fileOut) throws IOException {
        super(fileOut);
        in = new BufferedReader(new FileReader(fileIn));
    }

    public static void main(String[] args) throws IOException {
        Main main;
        if ("_std".equals(IO)) {
            main = new Main();
        } else if ("_iotxt".equals(IO)) {
            main = new Main("input.txt", "output.txt");
        } else {
            main = new Main(IO + ".in", IO + ".out");
        }
        main.solve();
        main.close();
    }

    String next() throws IOException {
        while (stok == null || !stok.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null) {
                return null;
            }
            stok = new StringTokenizer(s);
        }
        return stok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    int[] nextIntArray(int len) throws IOException {
        int[] a = new int[len];
        for (int i = 0; i < len; i++) {
            a[i] = nextInt();
        }
        return a;
    }

    int[] nextIntArraySorted(int len) throws IOException {
        int[] a = nextIntArray(len);
        shuffle(a);
        Arrays.sort(a);
        return a;
    }

    void shuffle(int[] a) {
        for (int i = 1; i < a.length; i++) {
            int x = rand.nextInt(i + 1);
            int _ = a[i];
            a[i] = a[x];
            a[x] = _;
        }
    }

    void shuffleAndSort(int[] a) {
        shuffle(a);
        Arrays.sort(a);
    }

    boolean nextPermutation(int[] p) {
        for (int a = p.length - 2; a >= 0; --a) {
            if (p[a] < p[a + 1])
                for (int b = p.length - 1; ; --b)
                    if (p[b] > p[a]) {
                        int t = p[a];
                        p[a] = p[b];
                        p[b] = t;
                        for (++a, b = p.length - 1; a < b; ++a, --b) {
                            t = p[a];
                            p[a] = p[b];
                            p[b] = t;
                        }
                        return true;
                    }
        }
        return false;
    }

    <T> List<T>[] createAdjacencyList(int n) {
        List<T>[] res = new List[n];
        for (int i = 0; i < n; i++) {
            res[i] = new ArrayList<>();
        }
        return res;
    }

    void println(Object... a) {
        for (int i = 0; i < a.length; i++) {
            if (i != 0) {
                print(" ");
            }
            print(a[i]);
        }
        println();
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        c342 solver = new c342();
        solver.solve(1, in, out);
        out.close();
    }

    static class c342 {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            double r = in.nextInt();
            double h = in.nextInt();
            int n1 = (int) (Math.floor((h - r / 2) / r) + 1) * 2;
            double top = h + r * (1 - n1 / 2);
            out.println(n1 + ((top >= Math.sqrt(3.0 * r * r / 4)) ? 1 : 0));
        }

    }

    static class InputReader {
        private BufferedReader reader;
        private StringTokenizer stt;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

        public String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                return null;
            }
        }

        public String next() {
            while (stt == null || !stt.hasMoreTokens()) {
                stt = new StringTokenizer(nextLine());
            }
            return stt.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.io.*;
import java.util.*;

public class Pr342C {
	public static void main(String[] args) throws IOException {
		new Pr342C().run();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st;

	String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out, true);
		solve();
		out.flush();
	}

	class point {
		int x;
		int y;

		public point() {

		}

		public point(int x, int y) {
			this.x = x;
			this.y = y;
		}
	}

	void solve() throws IOException {
		int r = nextInt();
		int h = nextInt();
		int cnt = 2 * (h / r);
		if ((h % r) >= r * (Math.sqrt(3)) / 2) {
			cnt += 3;
		} else if ((h % r) * 2 >= r) {
			cnt += 2;
		} else {
			cnt++;
		}

		out.println(cnt);
	}
}

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.util.Scanner;

public class popo {

    public static void main(String[] args) {

        InputReader in=new InputReader(System.in);
       // Scanner in=new Scanner(System.in);
        PrintWriter out=new PrintWriter(System.out);

        int r=in.nextInt();
        int h=in.nextInt();
        int k=2*(h/r);
        int rem=h%r;
        if(2*rem<r)k++;
        else if((double)(2*rem)<Math.sqrt(3)*r)k+=2;
        else k+=3;
        out.print(k);
        out.close();
    }

    static class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int snext() {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) {
                curChar = 0;
                try {
                    snumChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = snext();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public long nextLong() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = snext();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public int[] nextIntArray(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

        public String readString() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = snext();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
}

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.Map;

/**
 * Created by hama_du on 15/05/23.
 */
public class C {
    public static void main(String[] args) {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int r = in.nextInt();
        int h = in.nextInt();

        int ans = (h / r) * 2;
        int left = r + (h % r);
        if (left >= (1 + Math.sqrt(3) / 2) * r) {
            ans += 3;
        } else if (left >= 1.5 * r) {
            ans += 2;
        } else {
            ans += 1;
        }
        out.println(ans);
        out.flush();
    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        private int next() {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public char nextChar() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            if ('a' <= c && c <= 'z') {
                return (char)c;
            }
            if ('A' <= c && c <= 'Z') {
                return (char)c;
            }
            throw new InputMismatchException();
        }

        public String nextToken() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            StringBuilder res = new StringBuilder();
            do {
                res.append((char)c);
                c = next();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public int nextInt() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = next();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = next();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public long nextLong() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            long sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = next();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = next();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }

    static void debug(Object... o) {
        System.err.println(Arrays.deepToString(o));
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

/**
 * Date: 23.06.13 at 15:29
 *
 * @author Nickolay Polyarniy aka PolarNick
 */
public class ProblemC {

    public void solve() throws Exception {
        long r = 2 * nextLong();
        long h = 2 * nextLong();
        long res = 0;
        res += (h / r) * 2;
//        out.println(res + " h=" + h + " r=" + r);
        h -= (h / r) * r;
//        out.println(res + " h=" + h + " r=" + r);
        if (h < r / 2) {
            res++;
            out.println(res);
        } else {
            if (h >= r / 2) {
                res += 2;
            }
//            out.println(res);
            if (3 * r * r <= 4 * h * h) {
                res++;
            }
            out.println(res);
        }
    }

    public static void main(String[] args) throws Exception {
        ProblemC problem = new ProblemC();
        problem.solve();
        problem.close();
    }

    BufferedReader in;
    PrintWriter out;
    String curLine;
    StringTokenizer tok;
    final String delimeter = " ";
    final String endOfFile = "";

    public ProblemC(BufferedReader in, PrintWriter out) throws Exception {
        this.in = in;
        this.out = out;
        curLine = in.readLine();
        if (curLine == null || curLine == endOfFile) {
            tok = null;
        } else {
            tok = new StringTokenizer(curLine, delimeter);
        }
    }

    public ProblemC() throws Exception {
        this(new BufferedReader(new InputStreamReader(System.in)),
                new PrintWriter(System.out));
    }

    public ProblemC(String filename) throws Exception {
        this(new BufferedReader(new FileReader(filename + ".in")),
                new PrintWriter(filename + ".out"));
    }

    public boolean hasMore() throws Exception {
        if (tok == null || curLine == null) {
            return false;
        } else {
            while (!tok.hasMoreTokens()) {
                curLine = in.readLine();
                if (curLine == null || curLine.equalsIgnoreCase(endOfFile)) {
                    tok = null;
                    return false;
                } else {
                    tok = new StringTokenizer(curLine);
                }
            }
            return true;
        }
    }

    public String nextWord() throws Exception {
        if (!hasMore()) {
            return null;
        } else {
            return tok.nextToken();
        }
    }

    public int nextInt() throws Exception {
        return Integer.parseInt(nextWord());
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextWord());
    }

    public int[] readIntArray(int n) throws Exception {
        int[] res = new int[n];
        for (int i = 0; i < n; i++) {
            res[i] = nextInt();
        }
        return res;
    }

    public void close() throws Exception {
        in.close();
        out.close();
    }

}

import java.util.*;

public class Main{
   public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int r = sc.nextInt();
		int h = sc.nextInt();
		int ans1 = 2 * (h * 2 + r) / (2 * r);
		int ans2 = 1 + 2 * (int)((2 * h + r * (2 - Math.sqrt(3))) / (2 * r));
		System.out.println(Math.max(ans1, ans2));
	}
}

import java.util.*;
import java.io.*;
public class CF342C {
    BufferedReader br;
    PrintWriter out;
    StringTokenizer st;
    boolean eof;
    void solve() throws IOException {
        long r = nextLong();
        long h = nextLong();
        long res = 0L;
        res += 2 * (h / r);
        h = h % r;
        if(2 * h < r) {
            res = res + 1;
        }
        else if(4 * h * h < 3 * r * r) {
            res = res + 2;
        }
        else
            res = res + 3;
        out(res);

    }
    private void outln(Object o) {
        System.out.println(o);
    }
    private void out(Object o) {
        System.out.print(o);
    }
    public CF342C() throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        solve();
        out.close();
    }
    public static void main(String[] args) throws IOException {
        new CF342C();
    }

    public long[] nextLongArr(int n) throws IOException{
        long[] res = new long[n];
        for(int i = 0; i < n; i++)
            res[i] = nextLong();
        return res;
    }
    public int[] nextIntArr(int n) throws IOException {
        int[] res = new int[n];
        for(int i = 0; i < n; i++)
            res[i] = nextInt();
        return res;
    }
    public String nextToken() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                eof = true;
                return null;
            }
        }
        return st.nextToken();
    }
    public String nextString() {
        try {
            return br.readLine();
        } catch (IOException e) {
            eof = true;
            return null;
        }
    }
    public int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    public long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    public double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
}

/**
 * Created with IntelliJ IDEA.
 * User: zangetsu
 * Date: 9/1/13
 */

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.lang.reflect.Array;
import java.util.*;

public class Main_A {

    /**
     * @param args
     * @throws IOException
     */

    static InputReader scan = new InputReader(System.in);
    static PrintWriter pw = new PrintWriter(System.out);
    public static void main(String[] args) throws IOException {
        int r = scan.nextInt(), h = scan.nextInt();
        // compute //
        int ans = 0;

        ans += h / r * 2;

        h = h % r;
        double hh = (double) h;
        if (hh >= r * Math.sqrt(3.0 / 4.0)) {
            ans += 3;
        } else if (hh >= ((double) r) / 2.0) {
            ans += 2;
        } else {
            ans += 1;
        }

        pw.println(ans);
        pw.close();
    }

}

class InputReader {

    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }
}

class ArrayUtils {
    private static int[] tempInt = new int[0];

    public static int[] sort(int[] array, IntComparator comparator) {
        return sort(array, 0, array.length, comparator);
    }

    public static int[] sort(int[] array, int from, int to,
                             IntComparator comparator) {
        ensureCapacityInt(to - from);
        System.arraycopy(array, from, tempInt, 0, to - from);
        sortImpl(array, from, to, tempInt, 0, to - from, comparator);
        return array;
    }

    private static void ensureCapacityInt(int size) {
        if (tempInt.length >= size)
            return;
        size = Math.max(size, tempInt.length << 1);
        tempInt = new int[size];
    }

    private static void sortImpl(int[] array, int from, int to, int[] temp,
                                 int fromTemp, int toTemp, IntComparator comparator) {
        if (to - from <= 1)
            return;
        int middle = (to - from) >> 1;
        int tempMiddle = fromTemp + middle;
        sortImpl(temp, fromTemp, tempMiddle, array, from, from + middle,
                comparator);
        sortImpl(temp, tempMiddle, toTemp, array, from + middle, to, comparator);
        int index = from;
        int index1 = fromTemp;
        int index2 = tempMiddle;
        while (index1 < tempMiddle && index2 < toTemp) {
            if (comparator.compare(temp[index1], temp[index2]) <= 0)
                array[index++] = temp[index1++];
            else
                array[index++] = temp[index2++];
        }
        if (index1 != tempMiddle)
            System.arraycopy(temp, index1, array, index, tempMiddle - index1);
        if (index2 != toTemp)
            System.arraycopy(temp, index2, array, index, toTemp - index2);
    }

}

interface IntComparator {
    public static final IntComparator DEFAULT = new IntComparator() {
        public int compare(int first, int second) {
            if (first < second)
                return -1;
            if (first > second)
                return 1;
            return 0;
        }
    };

    public int compare(int first, int second);
}

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class _342C {
    public static void main(String[] args) throws Exception {
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        double r;
        double h;
        final double a = 1.70710678119;
        String s[] = input.readLine().split(" ");
        r = Double.parseDouble(s[0]);
        h = Double.parseDouble(s[1]);
        double cond = 0.0;
        int count = 0;
        while (cond + r <= h + r / 2.0) {
            count += 2;
            cond += r;
        }
        if (h + r - cond >= a * r / 2.0) {
            count++;
        }
        System.out.println(count);
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class _342C {
    public static void main(String[] args) throws Exception {
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        double r;
        double h;
        final double a = 0.85355339059;
        String s[] = input.readLine().split(" ");
        r = Double.parseDouble(s[0]);
        h = Double.parseDouble(s[1]);
        double cond = 0.0;
        int count = 0;
        while (cond <= h - r / 2.0) {
            count += 2;
            cond += r;
        }
        if (h + r - cond >= a * r) {
            count++;
        }
        System.out.println(count);
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;

public class CupboardAndBalloons {
	public static void main(String[] args) {
		MyScanner sc = new MyScanner();

		int R = sc.nextInt();
		int H = sc.nextInt();

		int cbPart = H / R;
		int cbRemn = H % R;
		if (cbRemn >= (R + 1) / 2) {
			cbPart++;
		}
		int htRemn = H + R - R * cbPart;
		int tpPart = (4L * htRemn * htRemn >= 3L * R * R) ? 1 : 0;

		System.out.println(2 * cbPart + tpPart);
	}

	public static class MyScanner {
		BufferedReader br;
		StringTokenizer st;

		public MyScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		String nextLine() {
			String str = "";
			try { str = br.readLine(); }
			catch (IOException e) { e.printStackTrace(); }
			return str;
		}
	}
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {

    void solve() throws Exception{
        int r = in.nextInt();
        int  h = in.nextInt();
        int ans = (h / r) * 2;
        h = h % r;
        if (2 * h < r)
            ans ++;
        else if (2.0*h < Math.sqrt(3)*r)
            ans+=2;
        else
            ans+=3;
        out.println(ans);
    }

    String input = "";
    String output = "";
    FastScanner in;
    PrintWriter out;

    void run() throws Exception {
        if (input.length() == 0) {
            in = new FastScanner(System.in);
        } else {
            in = new FastScanner(new File(input));
        }
        if (output.length() == 0) {
            out = new PrintWriter(System.out);
        } else {
            out = new PrintWriter(new File(output));
        }

        solve();

        out.close();

    }

    public static void main(String[] args) throws Exception {
        new C().run();
    }

    class FastScanner {

        BufferedReader bf;
        StringTokenizer st;

        public FastScanner(InputStream is) {
            bf = new BufferedReader(new InputStreamReader(is));
        }

        public FastScanner(File fr) throws FileNotFoundException {
            bf = new BufferedReader(new FileReader(fr));
        }

        public String next() {
            try {
                while (st == null || !st.hasMoreTokens()) {
                    st = new StringTokenizer(bf.readLine());
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Locale;
import java.util.StringTokenizer;

public class C {

	private void solve() throws IOException {
		int r = nextInt();
		int h = nextInt();

		int k = h / r * 2;
		int mod = h % r;
		if (mod * 2 >= r) {
			k += 2;
			double nh = k / 2 * r + r * Math.sqrt(3) / 2;
			if (nh - 1e-9 <= h + r) {
				k++;
			}
		} else {
			k++;
		}

		println(k);
	}

	private String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}

	private int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(nextToken());
	}

	private double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(nextToken());
	}

	private long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	private void print(Object o) {
		writer.print(o);
	}

	private void println(Object o) {
		writer.println(o);
	}

	private void printf(String format, Object... o) {
		writer.printf(format, o);
	}

	public static void main(String[] args) {
		long time = System.currentTimeMillis();
		Locale.setDefault(Locale.US);
		new C().run();
		System.err.printf("%.3f\n", 1e-3 * (System.currentTimeMillis() - time));
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter writer;

	private void run() {
		try {
			reader = new BufferedReader(new InputStreamReader(System.in));
			writer = new PrintWriter(System.out);
			solve();
			reader.close();
			writer.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(13);
		}
	}
}

import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.math.*;
import java.net.*;

public class Task{
    public static void main(String[] args) throws IOException{
        new Task().run();
    }

    StreamTokenizer in;
    Scanner ins;
    PrintWriter out;

    int nextInt() throws IOException{
        in.nextToken();
        return (int)in.nval;
    }

    long nextLong() throws IOException{
        in.nextToken();
        return (long)in.nval;
    }

    double nextDouble() throws IOException{
        in.nextToken();
        return in.nval;
    }

    char nextChar() throws IOException{
        in.nextToken();
        return (char)in.ttype;
    }

    String nextString() throws IOException{
        in.nextToken();
        return in.sval;
    }

    long gcdLight(long a, long b){
        a = Math.abs(a);
        b = Math.abs(b);
        while(a != 0 && b != 0){
            if(a > b)
                a %= b;
            else
                b %= a;
        }
        return a + b;
    }

    Task.ForGCD gcd(int a,int b){
        Task.ForGCD tmp = new Task.ForGCD();
        if(a == 0){
            tmp.x = 0;
            tmp.y = 1;
            tmp.d = b;
        }else{
            Task.ForGCD tmp1 = gcd(b%a, a);
            tmp.d = tmp1.d;
            tmp.y = tmp1.x;
            tmp.x = tmp1.y - tmp1.x*(b/a);
        }
        return tmp;
    }

    void run() throws IOException{
        in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        ins = new Scanner(System.in);
        out = new PrintWriter(System.out);
        try{
            if(System.getProperty("xDx")!=null){
                in = new StreamTokenizer(new BufferedReader(new FileReader("input.txt")));
                ins = new Scanner(new FileReader("input.txt"));
                out = new PrintWriter(new FileWriter("output.txt"));
            }
        }catch(Exception e){

        }

        long r = nextInt(), h = nextInt();
        long res = h/r * 2;
        if((h%r)*2 >= r){
            res += 2;
            long p1 = 3*r;
            p1 *= r;
            long p2 = 2*(h%r);
            p2 = p2*p2;
            if(p2 >= p1){
                res++;
            }
        }else{
            res++;
        }
        out.print(res);

        out.close();
    }

    class ForGCD{
        int x,y,d;
    }

    class Boxes implements Comparable{
        public long k,a;
        public Boxes(long k, long a){
            this.k = k;
            this.a = a;
        }

        public int compareTo(Object obj){
            Task.Boxes b = (Task.Boxes) obj;
            if(k < b.k)
                return -1;
            else
                if(k == b.k)
                    return 0;
                else
                    return 1;
        }
    }
}

import static java.util.Arrays.deepToString;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class Main {

    static void solve() throws IOException {
        int r = nextInt();
        int h = nextInt();
        int count = h / r * 2;
        h = h - h / r * r;
        if (h >= Math.sqrt(3) * r / 2) {
            count = count + 3;
        } else if (h >= r / 2.0) {
            count = count + 2;
        } else {
            count++;
        }
        writer.println(count);
    }

    public static void main(String[] args) throws Exception {
        reader = new BufferedReader(new InputStreamReader(System.in));
        writer = new PrintWriter(System.out);
        // reader = new BufferedReader(new FileReader("input.txt"));
        // writer = new PrintWriter("output.txt");
        setTime();
        solve();
        printTime();
        printMemory();

        writer.close();
    }

    static BufferedReader reader;
    static PrintWriter writer;
    static StringTokenizer tok = new StringTokenizer("");
    static long systemTime;

    static void debug(Object... o) {
        System.err.println(deepToString(o));
    }

    static void setTime() {
        systemTime = System.currentTimeMillis();
    }

    static void printTime() {
        System.err.println("Time consumed: "
                + (System.currentTimeMillis() - systemTime));
    }

    static void printMemory() {
        System.err.println("Memory consumed: "
                + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime()
                        .freeMemory()) / 1000 + "kb");
    }

    static String next() {
        while (!tok.hasMoreTokens()) {
            String w = null;
            try {
                w = reader.readLine();
            } catch (Exception e) {
                e.printStackTrace();
            }
            if (w == null)
                return null;
            tok = new StringTokenizer(w);
        }
        return tok.nextToken();
    }

    static int nextInt() {
        return Integer.parseInt(next());
    }

    static long nextLong() {
        return Long.parseLong(next());
    }

    static double nextDouble() {
        return Double.parseDouble(next());
    }

    static BigInteger nextBigInteger() {
        return new BigInteger(next());
    }
}

/*
    Date         :
    Problem Name :
    Location     :
    Algorithm    :
    Status       :
    Coding       :
    Thinking     :
    Time spent   :
    Note         :
*/
import java.util.*;
import java.io.*;
public class Main {
    static BufferedReader reader
        = new BufferedReader(new InputStreamReader(System.in));
    public static void main(String[] args){
        String[] inp = getLine().split("\\s+");
        double r = Integer.parseInt(inp[0]);
        double h = Integer.parseInt(inp[1]);
        int a = (int) Math.floor(h / r + 0.5 + 0.0000001) * 2;
        int b = (int) Math.floor(h / r + 1 - Math.sqrt(3) / 2 + 0.00000001) * 2 + 1;
        System.out.println(Math.max(a, b));
    }
    static String getLine(){
        try {
            return reader.readLine().trim();
        } catch (Exception e){
        }
        return null;
    }
}

import java.util.*;
import java.io.*;
public class Main {
    static BufferedReader reader
		= new BufferedReader(new InputStreamReader(System.in));
    static StringBuilder out = new StringBuilder();

    public static void main(String[] args){
        int[] inp = nextIntArray();
        double r, h;
        r = inp[0]; h = inp[1];
        double a = (h + r/2) / r;
        double b =  ( ( (2 - Math.sqrt(3)) * r / 2 ) + h) / r;
        a = 2 * Math.floor(0.0000001 + a);
        b = 1 + 2 * Math.floor(0.0000001 + b);
        out.append((int) Math.max(a, b));

        System.out.println(out);
    }

    // the followings are methods to take care of inputs.
    static int nextInt(){
        return Integer.parseInt(nextLine());
    }
    static long nextLong(){
        return Long.parseLong(nextLine());
    }
    static int[] nextIntArray(){
        String[] inp = nextLine().split("\\s+");
        int[] ary = new int[inp.length]; for (int i = 0; i < ary.length; i++){
            ary[i] = Integer.parseInt(inp[i]);
        }
        return ary;
    }
    static int[] nextIntArrayFrom1(){
        String[] inp = nextLine().split("\\s+");
        int[] ary = new int[inp.length + 1];
        for (int i = 0; i < inp.length; i++){
            ary[i+1] = Integer.parseInt(inp[i]);
        }
        return ary;
    }
    static long[] nextLongArray(){
        String[] inp = nextLine().split("\\s+");
        long[] ary = new long[inp.length];
        for (int i = 0; i < inp.length; i++){
            ary[i] = Long.parseLong(inp[i]);
        }
        return ary;
    }
    static long[] nextLongArrayFrom1(){
        String[] inp = nextLine().split("\\s+");
        long[] ary = new long[inp.length + 1];
        for (int i = 0; i < inp.length; i++){
            ary[i+1] = Long.parseLong(inp[i]);
        }
        return ary;
    }
	static String nextLine(){
		try {
			return reader.readLine().trim();
		} catch (Exception e){}
		return null;
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class CF {

    public static class Stage {
        int num;
        int left;
        int right;
    }

    public static void main(String[] args) throws IOException {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);

        int r = in.nextInt();
        int h = in.nextInt();

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

        int top = 0;
        if (doubleCount * r + Math.sqrt(3) / 2 * r <= h + r) top = 1;

        int res = doubleCount * 2 + top;

        if (doubleCount > 1) {
            doubleCount--;

            int top2 = 0;
            if (doubleCount * r + Math.sqrt(3) * r <= h + r) top2 = 1;
            res = Math.max(res, doubleCount * 2 + 1 + top2);
        }

        out.println(res);
        out.close();
    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }
}

import java.util.Scanner;

public class C_199_D2_C {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		long r = sc.nextLong();
		long h = sc.nextLong();
		int count = 0;
		count = (int) (h / r);
		h -= count * r;
		count *= 2;
		if (4 * h * h >= 3 * r * r) {
			count += 3;
		} else {
			if (h * 2 >= r ){
				count += 2;
			} else {
				count += 1;
			}
		}
		System.out.println(count);
		sc.close();
	}

}

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class Main
{

	private static BufferedReader in;
	private static BufferedWriter out;

	public static void main(String... args) throws IOException
	{
		// streams
		boolean file = false;
		if (file)
			in = new BufferedReader(new FileReader("input.txt"));
		else
			in = new BufferedReader(new InputStreamReader(System.in));
		out = new BufferedWriter(new OutputStreamWriter(System.out));
		StringTokenizer tok;

		// take input
		tok = new StringTokenizer(in.readLine());
		int r = Integer.parseInt(tok.nextToken());
		int h = Integer.parseInt(tok.nextToken());

		// make levels of two
		long sum = 0;
		long levels = (r/2 + h) / r;
		sum += levels*2;

		// last one
		long height = levels *r;
		double lastHeight =  r * Math.cos(Math.PI / 6.0);
		if (height + lastHeight < h + r)
			sum ++;

		System.out.println(sum);
		out.flush();
	}

}

import java.io.*;
import java.util.*;

public class Solution {
    public static void main(String[] args) throws IOException {
        Solution sol = new Solution();
        sol.run();
    }

    final double EPS = 1e-9;

    double sqr(double a) {
        return a * a;
    }

    double dist2(double ax, double ay, double bx, double by) {
        return sqr(ax - bx) + sqr(ay - by);
    }

    boolean inside(double r, double h, double cx, double cy) {
        double p = r / 2;
        if (cy - p < -EPS)
            return false;
        if (cy + p > h + r + EPS)
            return false;
        if (cx - p < -EPS)
            return false;
        if (cx + p > 2 * r + EPS)
            return false;
        if (cy > h - EPS)
            return dist2(r, h, cx, cy) < sqr(p + EPS);
        return true;
    }

    void run() throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stok = new StringTokenizer(reader.readLine());
        int r = Integer.parseInt(stok.nextToken());
        int h = Integer.parseInt(stok.nextToken());
        int lf = 0, rg = (r + h) / r + 1;
        double cx = r / 2.0;
        while (lf + 1 < rg) {
            int mid = (lf + rg) / 2;
            double cy = r * (mid + 0.5);
            if (inside(r, h, cx, cy))
                lf = mid;
            else
                rg = mid;
        }
        for (; rg >= lf; --rg) {
            double cy = r * (rg + 0.5);
            if (inside(r, h, cx, cy))
                break;
        }
        int ans = 0;
        if (rg >= lf)
            ans += 2 * (rg + 1);
        cx = r;
        double cy = r / 2.0;
        if (rg >= lf)
            cy = r * (rg + 0.5 + Math.sqrt(0.75));
        if (inside(r, h, cx, cy))
            ++ans;
        System.out.println(ans);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

/**
 * Created with IntelliJ IDEA.
 * User: Evgeniy
 * Date: 9/11/13
 * Time: 4:22 PM
 */
public class Main {

    StringTokenizer tokenizer = new StringTokenizer("");
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw = new PrintWriter(System.out);

    public static void main(String[] args) {
        new Main().solve();
    }

    void solve() {
        double r = nextDouble();
        double h = nextDouble();

        h /= r;
        r = 1;

        h += 1e-9;

        int res = 2 * (int) (Math.floor(h));
        h -= Math.floor(h);

        if (h >= 0.4999999999) {
            res += 2;
            if (1 + Math.sqrt(3) / 2.0 < h + 1) {
                res++;
            }
        } else {
            res++;
        }

        System.out.println(res);
    }

    String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            return "";
        }
    }

    String nextToken() {
        if (!tokenizer.hasMoreElements()) {
            tokenizer = new StringTokenizer(nextLine());
        }
        return tokenizer.nextToken();

    }

    int nextInt() {
        return Integer.parseInt(nextToken());
    }

    double nextDouble() {
        return Double.parseDouble(nextToken());
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class cf342c {
  static FastIO in = new FastIO(), out = in;

  public static void main(String[] args) {
    int r = in.nextInt();
    int h = in.nextInt();
    int k = (2 * h + r) / (2 * r);
    int ans = 2 * k;
    double height = 0;
    if (k == 0) {
      height = r;
    } else {
      height = r;
      height *= k;
      height += r * Math.sqrt(3) / 2.;
    }
    if (height - 1e-9 < h + r)
      ans++;
    out.println(ans);
    out.close();
  }

  static class FastIO extends PrintWriter {
    BufferedReader br;
    StringTokenizer st;

    public FastIO() {
      this(System.in, System.out);
    }

    public FastIO(InputStream in, OutputStream out) {
      super(new BufferedWriter(new OutputStreamWriter(out)));
      br = new BufferedReader(new InputStreamReader(in));
      scanLine();
    }

    public void scanLine() {
      try {
        st = new StringTokenizer(br.readLine().trim());
      } catch (Exception e) {
        throw new RuntimeException(e.getMessage());
      }
    }

    public int numTokens() {
      if (!st.hasMoreTokens()) {
        scanLine();
        return numTokens();
      }
      return st.countTokens();
    }

    public String next() {
      if (!st.hasMoreTokens()) {
        scanLine();
        return next();
      }
      return st.nextToken();
    }

    public double nextDouble() {
      return Double.parseDouble(next());
    }

    public long nextLong() {
      return Long.parseLong(next());
    }

    public int nextInt() {
      return Integer.parseInt(next());
    }
  }
}

import java.util.Scanner;
import java.io.StreamTokenizer;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintStream;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author KNIGHT0X300
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputStreamReader in = new InputStreamReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    StreamTokenizer in;
    PrintWriter out;
    BufferedReader re;
    Scanner sc;
    public void solve (int testNumber, InputStreamReader in, PrintWriter out)  {

          this.in = new StreamTokenizer(new BufferedReader(in));
          this.re =  new BufferedReader(in);
          this.sc = new Scanner(in);
          this.out = out;
          try {
                      this.solve();
                  } catch (IOException e) {
                      e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
                  }
          out.flush();

    }

         /////////////////////////////////////////////////////////////
     int nextInt() throws IOException
       {
          in.nextToken();
          return (int)in.nval;
       }

     void solve() throws IOException
       {
           int r=nextInt(),h=nextInt();
           int ans=h/r;
           ans*=2;
           h%=r;
           if((double)h>=(double)r*Math.sqrt(3)/2.0)ans+=3;
           else if((double)h>=(double)r/2.0) ans+=2;
           else
             ans+=1;
           out.println(ans);
         // do the sum
       }
}

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Solution {
    private IO io;
    private int ioMode = -1;
    private String problemName = "";
    private final String mjArgument = "master_j";

    public static void main(String programArguments[]) throws IOException{
        if(programArguments != null && programArguments.length > 0)
            new Solution().run(programArguments[0]);
        else
            new Solution().run(null);
    }

    private void run(String programArgument) throws IOException {
        //         _______________________________________________ _________
        //        |   Input Mode     |      Output Mode    | mode | comment |
        //        |------------------|---------------------|----- |---------|
        //        |   input.txt      |      System.out     |  0   |    mj   |
        //        |   System.in      |      System.out     |  1   |  T / CF |
        //        |<problemName>.in  |  <problemName>.out  |  2   |         |
        //        |   input.txt      |      output.txt     |  3   |    C    |
        //        |__________________|_____________________|______|_________|
        long nanoTime = 0;
        if(programArgument != null && programArgument.equals(mjArgument)) // mj
            ioMode = 0;
        else if(System.getProperty("ONLINE_JUDGE") != null) // T / CF
            ioMode = 1;
        else
            ioMode = 2;
        switch(ioMode){
            case -1:
                try{
                    throw new Exception("<ioMode> init failure") ;
                }catch (Exception e){
                    e.printStackTrace();
                }
                return;
            case 0:
                break;
            case 1:
                break;
            case 2:
                if(problemName.length() == 0){
                    try{
                        throw new Exception("<problemName> init failure");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return;
                }
            case 3:
                break;
        }
        io = new IO(ioMode, problemName);
        if(ioMode == 0){
            System.out.println("File output : \n<start>");
            System.out.flush();
            nanoTime = System.nanoTime();
        }
        solve();
        io.flush();
        if(ioMode == 0){
            System.out.println("</start>");
            long t = System.nanoTime() - nanoTime;
            int d3 = 1000000000, d2 = 1000000, d1 = 1000;
            if(t>=d3)
                System.out.println(t/d3 + "." + t%d3 + " seconds");
            else if(t>=d2)
                System.out.println(t/d2 + "." + t%d2 + " millis");
            else if(t>=d1)
                System.out.println(t/d1 + "." + t%d1 + " micros");
            else
                System.out.println(t + " nanos");
            System.out.flush();
        }
    }

    private void solve() throws IOException {
        long r = io.nI(), h = io.nI(), ans = h / r;
        h %= r;
        if(2*h >= r)
            ans++;
        else
            h += r;
        ans *= 2;
        if(r*r + 4*h*h >= 4*r*r)
            ans++;
        io.wln(ans);
    }//2.2250738585072012e-308

    /**
     * Input-output class
     * @author master_j
     * @version 0.2.5
     */
    @SuppressWarnings("unused")
    private class IO{
        private boolean alwaysFlush;
        StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
        public IO(int ioMode, String problemName) throws IOException{
            Locale.setDefault(Locale.US);
            //         _______________________________________________ _________
            //        |   Input Mode     |      Output Mode    | mode | comment |
            //        |------------------|---------------------|----- |---------|
            //        |   input.txt      |      System.out     |  0   |    mj   |
            //        |   System.in      |      System.out     |  1   |  T / CF |
            //        |<problemName>.in  |  <problemName>.out  |  2   |         |
            //        |   input.txt      |      output.txt     |  3   |    C    |
            //        |__________________|_____________________|______|_________|
            switch(ioMode){
                case 0:
                    reader = new FileReader("input.txt");
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 1:
                    reader = new InputStreamReader(System.in);
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 2:
                    reader = new FileReader(problemName + ".in");
                    writer = new FileWriter(problemName + ".out");
                    break;
                case 3:
                    reader = new FileReader("input.txt");
                    writer = new FileWriter("output.txt");
                    break;
            }
            br = new BufferedReader(reader);
            in = new StreamTokenizer(br);
            out = new PrintWriter(writer);
            alwaysFlush = false;
        }
        public void setAlwaysFlush(boolean arg){alwaysFlush = arg;}
        public void wln(){out.println(); if(alwaysFlush)flush();}
        public void wln(int arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(long arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(double arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(String arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(boolean arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(char arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(float arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(Object arg){out.println(arg); if(alwaysFlush)flush();}
        public void w(int arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(long arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(double arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(String arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(boolean arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(char arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(float arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(Object arg){out.print(arg); if(alwaysFlush)flush();}
        public void wf(String format, Object...args){out.printf(format, args); if(alwaysFlush)flush();}
        public void flush(){out.flush();}
        public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
        public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
        public String nS() throws IOException {in.nextToken(); return in.sval;}
        public double nD() throws IOException {in.nextToken(); return in.nval;}
        public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
        public char nC() throws IOException {return (char)br.read();}
        public void wc(char...arg){for(char c : arg){in.ordinaryChar(c);in.wordChars(c, c);}}
        public void wc(String arg){wc(arg.toCharArray());}
        public void wc(char arg0, char arg1){in.ordinaryChars(arg0, arg1); in.wordChars(arg0, arg1);}
        public boolean eof(){return in.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol(){return in.ttype == StreamTokenizer.TT_EOL;}
    }
}

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;
import java.io.Writer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Dylan
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskC {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
        int r = in.nextInt();
        int h = in.nextInt();
        int ans = (h / r) * 2;
        double hh = 1.0 * h - ans / 2 * r;
        if (2 * hh >= r) {
            ans += 2;
            hh -= r;
        }
        if (2 * (hh + r) >= Math.sqrt(3) * r)
            ans++;
        out.println(ans);
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}

class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void println(Object... objects) {
        print(objects);
        writer.println();
    }

    public void close() {
        writer.close();
    }

    }

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;
import java.io.Writer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Dylan
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskC {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
        int r = in.nextInt();
        int h = in.nextInt();
        int ans = (h / r) * 2;
        double hh = 1.0 * h - ans / 2 * r;
        if (2 * hh >= r) {
            ans += 2;
            hh -= 1.0 * r;
        }
        if (2 * (hh + r)  + r >= (1.0 + Math.sqrt(3)) * r)
            ans++;
        out.println(ans);
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}

class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void println(Object... objects) {
        print(objects);
        writer.println();
    }

    public void close() {
        writer.close();
    }

    }

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Solution {
    private IO io;
    private int ioMode = -1;
    private String problemName = "";
    private final String mjArgument = "master_j";

    public static void main(String programArguments[]) throws IOException{
        if(programArguments != null && programArguments.length > 0)
            new Solution().run(programArguments[0]);
        else
            new Solution().run(null);
    }

    private void run(String programArgument) throws IOException {
        //         _______________________________________________ _________
        //        |   Input Mode     |      Output Mode    | mode | comment |
        //        |------------------|---------------------|----- |---------|
        //        |   input.txt      |      System.out     |  0   |    mj   |
        //        |   System.in      |      System.out     |  1   |  T / CF |
        //        |<problemName>.in  |  <problemName>.out  |  2   |         |
        //        |   input.txt      |      output.txt     |  3   |    C    |
        //        |__________________|_____________________|______|_________|
        long nanoTime = 0;
        if(programArgument != null && programArgument.equals(mjArgument)) // mj
            ioMode = 0;
        else if(System.getProperty("ONLINE_JUDGE") != null) // T / CF
            ioMode = 1;
        else
            ioMode = 2;
        switch(ioMode){
            case -1:
                try{
                    throw new Exception("<ioMode> init failure") ;
                }catch (Exception e){
                    e.printStackTrace();
                }
                return;
            case 0:
                break;
            case 1:
                break;
            case 2:
                if(problemName.length() == 0){
                    try{
                        throw new Exception("<problemName> init failure");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return;
                }
            case 3:
                break;
        }
        io = new IO(ioMode, problemName);
        if(ioMode == 0){
            System.out.println("File output : \n<start>");
            System.out.flush();
            nanoTime = System.nanoTime();
        }
        solve();
        io.flush();
        if(ioMode == 0){
            System.out.println("</start>");
            long t = System.nanoTime() - nanoTime;
            int d3 = 1000000000, d2 = 1000000, d1 = 1000;
            if(t>=d3)
                System.out.println(t/d3 + "." + t%d3 + " seconds");
            else if(t>=d2)
                System.out.println(t/d2 + "." + t%d2 + " millis");
            else if(t>=d1)
                System.out.println(t/d1 + "." + t%d1 + " micros");
            else
                System.out.println(t + " nanos");
            System.out.flush();
        }
    }

    private void solve() throws IOException {
        double r = io.nI(), h = io.nI();
        long ans = 0;
        while(h > r){
            h -= r;
            ans++;
        }
        if(h >= r/2){
            //h -= r/2;
            ans++;
        }else
            h += r;
        //h += r/2;
        ans *= 2;
        if(dist(0, 0, r/2, h) >= r)
            ans++;
        io.wln(ans);
    }//2.2250738585072012e-308

    double dist(double y1, double z1, double y2, double z2){
        double d1 = (y1-y2)*(y1-y2);
        double d2 = (z1-z2)*(z1-z2);
        double d = d1 + d2;
        return sqrt(d);
    }

    /**
     * Input-output class
     * @author master_j
     * @version 0.2.5
     */
    @SuppressWarnings("unused")
    private class IO{
        private boolean alwaysFlush;
        StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
        public IO(int ioMode, String problemName) throws IOException{
            Locale.setDefault(Locale.US);
            //         _______________________________________________ _________
            //        |   Input Mode     |      Output Mode    | mode | comment |
            //        |------------------|---------------------|----- |---------|
            //        |   input.txt      |      System.out     |  0   |    mj   |
            //        |   System.in      |      System.out     |  1   |  T / CF |
            //        |<problemName>.in  |  <problemName>.out  |  2   |         |
            //        |   input.txt      |      output.txt     |  3   |    C    |
            //        |__________________|_____________________|______|_________|
            switch(ioMode){
                case 0:
                    reader = new FileReader("input.txt");
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 1:
                    reader = new InputStreamReader(System.in);
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 2:
                    reader = new FileReader(problemName + ".in");
                    writer = new FileWriter(problemName + ".out");
                    break;
                case 3:
                    reader = new FileReader("input.txt");
                    writer = new FileWriter("output.txt");
                    break;
            }
            br = new BufferedReader(reader);
            in = new StreamTokenizer(br);
            out = new PrintWriter(writer);
            alwaysFlush = false;
        }
        public void setAlwaysFlush(boolean arg){alwaysFlush = arg;}
        public void wln(){out.println(); if(alwaysFlush)flush();}
        public void wln(int arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(long arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(double arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(String arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(boolean arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(char arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(float arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(Object arg){out.println(arg); if(alwaysFlush)flush();}
        public void w(int arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(long arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(double arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(String arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(boolean arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(char arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(float arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(Object arg){out.print(arg); if(alwaysFlush)flush();}
        public void wf(String format, Object...args){out.printf(format, args); if(alwaysFlush)flush();}
        public void flush(){out.flush();}
        public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
        public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
        public String nS() throws IOException {in.nextToken(); return in.sval;}
        public double nD() throws IOException {in.nextToken(); return in.nval;}
        public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
        public char nC() throws IOException {return (char)br.read();}
        public void wc(char...arg){for(char c : arg){in.ordinaryChar(c);in.wordChars(c, c);}}
        public void wc(String arg){wc(arg.toCharArray());}
        public void wc(char arg0, char arg1){in.ordinaryChars(arg0, arg1); in.wordChars(arg0, arg1);}
        public boolean eof(){return in.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol(){return in.ttype == StreamTokenizer.TT_EOL;}
    }
}

import java.util.*;
import java.io.*;

public class C {
/*

 */
    public static BR in;
    public static LR lin;
    public static PrintWriter out;
    public static PrintWriter fout;
    static {
        try {
            in = new BR();
            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out  ) ) );
            fout = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream("output.txt") ) ) );
        }
        catch (Exception e){

        }
    }

    public static boolean bg = true;
    public static void main(String[] args) throws Exception {
        s1();
        out.close();
    }
    private static void s1() throws Exception {
        int r = in.ni();
        int h = in.ni();
        int R = r * 2;
        int H = h * 2;
        int max = Integer.MIN_VALUE;
        {
            int k1 = ((H+r)/R)*2;
            long left = (H+R) - R*(k1/2);
            long right = left * left *4l;
            long remainpow = (long)R;
            remainpow *= remainpow;
            remainpow *= 3l;
            if (right >= remainpow){
                k1 += 1;
            }
            if (k1 > max) max = k1;
        }
        pn(max);
    }

    private static void pn(Object... o1) {
        for (int i = 0; i < o1.length; i++) {
            if (i != 0) out.print(" ");
            out.print(o1[i]);
        }
        out.println();
    }

    private static class Geo {
        public static double eps = 1e-8;

        public static int sign(double n1) {
            if (Math.abs(n1) <= eps) return 0;
            if (n1 > 0) return 1;
            return -1;
        }
    }
    private static class LR {
    }

    private static class BR {
        BufferedReader k1 = null;
        StringTokenizer k2 = null;

        public BR() {
            k1 = new BufferedReader(new InputStreamReader(System.in));
        }

        public String nx() throws Exception {
            for (;;) {
                if (k2 == null || !k2.hasMoreTokens()) {
                    String temp = k1.readLine();
                    if (temp == null) return null;
                    k2 = new StringTokenizer(temp);
                }
                else
                    break;
            }

            return k2.nextToken();
        }

        public int ni() throws Exception {
            return Integer.parseInt(nx());
        }
    }

}

import java.io.*;
import java.util.*;
import java.math.*;

public class Main
{
	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	StringTokenizer tokenizer=null;

	public static void main(String[] args) throws IOException
	{
		new Main().execute();
	}

	void debug(Object...os)
	{
		System.out.println(Arrays.deepToString(os));
	}

	int ni() throws IOException
	{
		return Integer.parseInt(ns());
	}

	long nl() throws IOException
	{
		return Long.parseLong(ns());
	}

	double nd() throws IOException
	{
		return Double.parseDouble(ns());
	}

	String ns() throws IOException
	{
		while (tokenizer == null || !tokenizer.hasMoreTokens())
			tokenizer = new StringTokenizer(br.readLine());
		return tokenizer.nextToken();
	}

	String nline() throws IOException
	{
		tokenizer=null;
		return br.readLine();
	}

	//Main Code starts Here
	int totalCases, testnum;
	int h,r;

	void execute() throws IOException
	{
		totalCases = 1;
		for(testnum = 1; testnum <= totalCases; testnum++)
		{
			if(!input())
				break;
			solve();
		}
	}

	void solve() throws IOException
	{
		int count = 0;
		count = count + (h/r) * 2;
		int left = h % r;

		if ((left - (Math.sqrt(3) * r)/2) > 1e-9) {
			count +=3;
		}
		else if (r/2.0 - left < 1e-9) {
			count+=2;
		}
		else {
			count+=1;
		}
		System.out.println(count);

	}

	boolean input() throws IOException
	{
		r = ni();
		h = ni();
		return true;
	}
}

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;
import java.io.Writer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Laputa
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskC {
    public void solve(int testNumber, InputReader cin, OutputWriter out) {
        int rrr=cin.nextInt();
        int hhh=cin.nextInt();
        double R=rrr;
        double H=hhh;

        int ans=Integer.MIN_VALUE;

        double r=R/2;
        double l1=2*R; // 4r
        double l2=R+Math.sqrt(3)*r; //2r+ sqrt3 r
        double l3=R;

        int cnt1=(int)((H+r)/R);
        //int aa=cnt1*4;

        for(int i=0;i<=cnt1;i++){
            //double h1=R*(cnt1-i);
            int tmp=(int)((H+R-R*(cnt1-i))/l2)*3+(cnt1-i)*2;
            ans=Math.max(ans,tmp);
        }

        ans=Math.max(ans,1);

        out.println(ans);
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}

class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void println(Object... objects) {
        print(objects);
        writer.println();
    }

    public void close() {
        writer.close();
    }

    }

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;

import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        new Main().run();
    }

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st = new StringTokenizer("");

    private void run() throws IOException {
//      in = new BufferedReader(new FileReader("input.txt"));
//      out = new PrintWriter("output.txt");

        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(new OutputStreamWriter(System.out));

        solve();
        in.close();
        out.close();
    }

    final double EPS = 0.00000001;
    private void solve() throws IOException {
        while(!EOF()){
            int r = nextInt(), h = nextInt();
            int cntOnHeight = (int)( ((int)(h/(r/2.0)))/2.0);
            int a = h - r * cntOnHeight;
            if((double)a >= r/2.0)
                cntOnHeight++;
            int ans = 2 * cntOnHeight;
            double sq = sqrt(((double)r/2.0) * ((double)r/2.0) + ((double)r * cntOnHeight - h - r) * ((double)r * cntOnHeight - h - r));
            if(sq > r || abs(sq - r) < EPS)
                ans++;
            out.println( ans );
        }
    }

    String nextToken() throws IOException {
        while (!st.hasMoreTokens())
            st = new StringTokenizer(in.readLine());
        return st.nextToken();
    }
    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
    String nextLine() throws IOException {
        st = new StringTokenizer("");
        return in.readLine();
    }
    boolean EOF() throws IOException {
        while (!st.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null)
                return true;
            st = new StringTokenizer(s);
        }
        return false;
    }
}

import java.util.*;
public class ProbC {
public static void main(String [] args){
Scanner in=new Scanner(System.in);
double r=in.nextDouble();
int h=in.nextInt();
int ans=2*(h/(int)r)+1;
double b=h%r;
double a=b-(Math.sqrt(3)/2)*r;
//System.out.println(ans+" "+a+" "+b+" "+r/2);
if(a>=0)
System.out.println(ans+2);
else if(b>=r/2)
System.out.println(ans+1);
else
System.out.println(ans);
}
}

import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Gaoyuan Chen
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskC {
    public void solve(int testNumber, Scanner in, PrintWriter out) {
        int r = in.nextInt(), h = in.nextInt();
        double d = (double)h / (double)r;
        int ans = 1;
        ans = Math.max(ans, 1 + ((int)(d+1-Math.sqrt(3)/2)) * 2);
        if(d >= 0.5)
            ans = Math.max(ans, 2 + ((int)(d-0.5)) * 2);
        out.println(ans);
    }
}

import java.util.*; //Scanner;
import java.io.PrintWriter; //PrintWriter

public class R199_Div2_C //Name: Cupboard and Balloons
{
	public static void main(String[] args) {
		Scanner      in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		solve(in, out);
		out.close();
		in.close();
	}

	public static void solve(Scanner in, PrintWriter out)
	{
		int r = in.nextInt();
		int h = in.nextInt();

        int cnt = h / r * 2;
        int h2 = h % r;
        if (h2 * 2 < r) cnt++;
        else if (h2 * 2 >= Math.sqrt(3) * r) cnt += 3;
        else cnt += 2;

		out.println(cnt);
	}
}

import java.io.*;
import java.util.StringTokenizer;

/**
 * @author kperikov
 */
public class C implements Runnable {

    PrintWriter out;
    BufferedReader br;
    StringTokenizer st;

    public static void main(String[] args) throws IOException {
        new Thread(new C()).start();
    }

    public String next() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(br.readLine());
        }
        return st.nextToken();
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public void run() {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(new BufferedOutputStream(System.out));
            solve();
            out.close();
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
    }

    public void solve() throws IOException {
        int r = nextInt();
        int h = nextInt();
        int ans = (h / r) * 2;
        h -= (h / r) * r;
        if (2 * h >= r) {
            ans += 2;
        } else {
            ans++;
        }
        if (3.0d * r * r <= 4.0d * h * h) {
            ans++;
        }
        out.println(ans);
    }
}

import java.io.*;
import java.util.*;

public class C199{

        private BufferedReader in;
        private StringTokenizer st;
        private PrintWriter out;

        void solve() throws IOException{

            int r = nextInt();
            int h = nextInt();
            int ans = h/r ;
            h %= r;
            if(h*2.0 >= Math.sqrt(3)*r) ans += 3;
            else if(h*2 < r) ans ++;
            else ans += 2;
            out.println(ans);

        }

        C199() throws IOException {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            eat("");
            solve();
            out.close();
        }

        private void eat(String str) {
            st = new StringTokenizer(str);
        }

        String next() throws IOException {
            while (!st.hasMoreTokens()) {
                String line = in.readLine();
                if (line == null) {
                    return null;
                }
                eat(line);
            }
            return st.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        public static void main(String[] args) throws IOException {
            new C199();
        }

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

}

import java.io.*;
import java.util.*;

public class C199{

        private BufferedReader in;
        private StringTokenizer st;
        private PrintWriter out;

        void solve() throws IOException{

            int r = nextInt();
            int h = nextInt();

            out.println( (2*h)/r + 1);

        }

        C199() throws IOException {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            eat("");
            solve();
            out.close();
        }

        private void eat(String str) {
            st = new StringTokenizer(str);
        }

        String next() throws IOException {
            while (!st.hasMoreTokens()) {
                String line = in.readLine();
                if (line == null) {
                    return null;
                }
                eat(line);
            }
            return st.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        public static void main(String[] args) throws IOException {
            new C199();
        }

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

}

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskC {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int r=in.nextInt();
        int h=in.nextInt();
        if(2*h>=r) {
            // we can organize two rows
            int doubletotalHeight=r+2*h;
            double eps=1e-8;
            int rows=(int)((h*1.0)/r+0.5+eps);
            //can we fit an extra ball?
            int extra=0;
            long x1=2*r;
            long y1=2*h+r;
            long y2=r+(rows-1)*2*r;
            long x2=r;
            if((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)>=4*r*r) {
               extra=1;
            }

            out.println(2*rows+extra);
        }
        else {
            out.println(1);
        }
    }
}

class InputReader {
    StringTokenizer st;
    BufferedReader in;
    public InputReader(InputStream ins)
    {
        in = new BufferedReader(new InputStreamReader(ins));
    }

    public String nextToken()
    {
        while(st==null || !st.hasMoreTokens())
        {
            try {
                st=new StringTokenizer(in.readLine());
            } catch (IOException e) {
                e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
            }
        }
        return st.nextToken();
    }
    public int nextInt()
    {

        return Integer.parseInt(nextToken());
    }

    }

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class C {
    public static void main(String[] args) throws Exception {
        InputStreamReader input = new InputStreamReader(System.in);
        BufferedReader read = new BufferedReader(input);

        String[] ss = read.readLine().split(" ");
        int r = Integer.parseInt(ss[0]);
        int h = Integer.parseInt(ss[1]);
        long ret = getCount(r, h);
        System.out.println(""+ret);
    }

    private static long getCount(long r, long h) {
        double height45 = h + Math.sqrt(2) / 2.0 * r;
        long side = (long) (Math.floor(height45 / (double)r));
        long ret = side * 2;
        double lastcenter = side * r - r / 2.0;
        double x = h + r/2.0 - lastcenter;
        double diag = Math.sqrt(x * x + r * r / 4.0);
        if (diag >= r) {
            ret++;
        }
        return ret;
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class C {
    public static void main(String[] args) throws Exception {
        InputStreamReader input = new InputStreamReader(System.in);
        BufferedReader read = new BufferedReader(input);

        String[] ss = read.readLine().split(" ");
        int r = Integer.parseInt(ss[0]);
        int h = Integer.parseInt(ss[1]);
        long ret = getCount(r, h);
        System.out.println(""+ret);
    }

    private static long getCount(long r, long h) {
        if (r > h * 2) return 1;
        double height45 = h + Math.sqrt(2) / 2.0 * r;
        long side = (long) (Math.floor(height45 / (double)r));
        long ret = side * 2;
        double lastcenter = side * r - r / 2.0;
        double x = h + r/2.0 - lastcenter;
        double diag = Math.sqrt(x * x + r * r / 4.0);
        if (diag >= r) {
            ret++;
        }
        return ret;
    }
}

import java.io.*;
import java.util.*;

public class Pr342C {
	public static void main(String[] args) throws IOException {
		new Pr342C().run();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st;

	String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out, true);
		solve();
		out.flush();
	}

	class point {
		int x;
		int y;

		public point() {

		}

		public point(int x, int y) {
			this.x = x;
			this.y = y;
		}
	}

	void solve() throws IOException {
		int r = nextInt();
		int h = nextInt();
		int cnt = 2 * (h / r);
		if ((h % r) >= r * (Math.ceil(Math.sqrt(3)) - 1)) {
			cnt += 3;
		} else if ((h % r) * 2 >= r) {
			cnt += 2;
		} else {
			cnt++;
		}
		out.println(cnt);
	}
}

import java.io.*;
import java.util.*;

public class Pr342C {
	public static void main(String[] args) throws IOException {
		new Pr342C().run();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st;

	String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out, true);
		solve();
		out.flush();
	}

	class point {
		int x;
		int y;

		public point() {

		}

		public point(int x, int y) {
			this.x = x;
			this.y = y;
		}
	}

	void solve() throws IOException {
		int r = nextInt();
		int h = nextInt();
		int cnt = 2 * (h / r);
		if ((h % r) * 2 >= r) {
			cnt += 2;
		} else {
			cnt++;
		}
		out.println(cnt);
	}
}

import java.io.*;
import java.util.*;

public class Pr342C {
	public static void main(String[] args) throws IOException {
		new Pr342C().run();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st;

	String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out, true);
		solve();
		out.flush();
	}

	class point {
		int x;
		int y;

		public point() {

		}

		public point(int x, int y) {
			this.x = x;
			this.y = y;
		}
	}

	void solve() throws IOException {
		int r = nextInt();
		int h = nextInt();
		int cnt = 2 * (h / r);
		if ((h % r) >= r * (Math.sqrt(3) - 1)) {
			cnt += 3;
		} else if ((h % r) * 2 >= r) {
			cnt += 2;
		} else {
			cnt++;
		}
		out.println(cnt);
	}
}

import java.io.*;
import java.util.*;

public class Pr342C {
	public static void main(String[] args) throws IOException {
		new Pr342C().run();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st;

	String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out, true);
		solve();
		out.flush();
	}

	class point {
		int x;
		int y;

		public point() {

		}

		public point(int x, int y) {
			this.x = x;
			this.y = y;
		}
	}

	void solve() throws IOException {
		int r = nextInt();
		int h = nextInt();
		// int dist = (int)Math.floor(2 * h + Math.sqrt(2) * 2 * r);
		int cnt = (2 * h) / r + 1;
		/*
		 * int cnt = 2 * (h / r); if ((h % r) >= r * (Math.ceil(Math.sqrt(3)) -
		 * 1)) { cnt += 3; } else if ((h % r) * 2 >= r) { cnt += 2; } else {
		 * cnt++; }
		 */
		out.println(cnt);
	}
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

/**
 * Date: 23.06.13 at 15:29
 *
 * @author Nickolay Polyarniy aka PolarNick
 */
public class ProblemC {

    public void solve() throws Exception {
        long r = 2 * nextLong();
        long h = 2 * nextLong();
        long res = 0;
        res += (h / r) * 2;
//        out.println(res + " h=" + h + " r=" + r);
        h -= (h / r) * r;
//        out.println(res + " h=" + h + " r=" + r);
        if (h == 0) {
            res++;
            out.println(res);
        } else {
            if (h >= r / 2) {
                res += 2;
            }
//            out.println(res);
            if (3 * r * r <= 4 * h * h) {
                res++;
            }
            out.println(res);
        }
    }

    public static void main(String[] args) throws Exception {
        ProblemC problem = new ProblemC();
        problem.solve();
        problem.close();
    }

    BufferedReader in;
    PrintWriter out;
    String curLine;
    StringTokenizer tok;
    final String delimeter = " ";
    final String endOfFile = "";

    public ProblemC(BufferedReader in, PrintWriter out) throws Exception {
        this.in = in;
        this.out = out;
        curLine = in.readLine();
        if (curLine == null || curLine == endOfFile) {
            tok = null;
        } else {
            tok = new StringTokenizer(curLine, delimeter);
        }
    }

    public ProblemC() throws Exception {
        this(new BufferedReader(new InputStreamReader(System.in)),
                new PrintWriter(System.out));
    }

    public ProblemC(String filename) throws Exception {
        this(new BufferedReader(new FileReader(filename + ".in")),
                new PrintWriter(filename + ".out"));
    }

    public boolean hasMore() throws Exception {
        if (tok == null || curLine == null) {
            return false;
        } else {
            while (!tok.hasMoreTokens()) {
                curLine = in.readLine();
                if (curLine == null || curLine.equalsIgnoreCase(endOfFile)) {
                    tok = null;
                    return false;
                } else {
                    tok = new StringTokenizer(curLine);
                }
            }
            return true;
        }
    }

    public String nextWord() throws Exception {
        if (!hasMore()) {
            return null;
        } else {
            return tok.nextToken();
        }
    }

    public int nextInt() throws Exception {
        return Integer.parseInt(nextWord());
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextWord());
    }

    public int[] readIntArray(int n) throws Exception {
        int[] res = new int[n];
        for (int i = 0; i < n; i++) {
            res[i] = nextInt();
        }
        return res;
    }

    public void close() throws Exception {
        in.close();
        out.close();
    }

}

/**
 * Created with IntelliJ IDEA.
 * User: zangetsu
 * Date: 9/1/13
 */

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.lang.reflect.Array;
import java.util.*;

public class Main_A {

    /**
     * @param args
     * @throws IOException
     */

    static InputReader scan = new InputReader(System.in);
    static PrintWriter pw = new PrintWriter(System.out);
    public static void main(String[] args) throws IOException {
        int r = scan.nextInt(), h = scan.nextInt();
        // compute //
        int ans = 0;

        if (h >= r / 2) {
            ans += h / r * 2;

            if (h % r >= r * Math.sqrt(3.0 / 4.0)) {
                ans += 3;
            } else if (h%r >= (double) r / 2.0) {
                ans += 2;
            } else {
                ans += 1;
            }

        } else {
            ans = 0;
        }
        pw.println(ans);
        pw.close();
    }

}

class InputReader {

    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }
}

class ArrayUtils {
    private static int[] tempInt = new int[0];

    public static int[] sort(int[] array, IntComparator comparator) {
        return sort(array, 0, array.length, comparator);
    }

    public static int[] sort(int[] array, int from, int to,
                             IntComparator comparator) {
        ensureCapacityInt(to - from);
        System.arraycopy(array, from, tempInt, 0, to - from);
        sortImpl(array, from, to, tempInt, 0, to - from, comparator);
        return array;
    }

    private static void ensureCapacityInt(int size) {
        if (tempInt.length >= size)
            return;
        size = Math.max(size, tempInt.length << 1);
        tempInt = new int[size];
    }

    private static void sortImpl(int[] array, int from, int to, int[] temp,
                                 int fromTemp, int toTemp, IntComparator comparator) {
        if (to - from <= 1)
            return;
        int middle = (to - from) >> 1;
        int tempMiddle = fromTemp + middle;
        sortImpl(temp, fromTemp, tempMiddle, array, from, from + middle,
                comparator);
        sortImpl(temp, tempMiddle, toTemp, array, from + middle, to, comparator);
        int index = from;
        int index1 = fromTemp;
        int index2 = tempMiddle;
        while (index1 < tempMiddle && index2 < toTemp) {
            if (comparator.compare(temp[index1], temp[index2]) <= 0)
                array[index++] = temp[index1++];
            else
                array[index++] = temp[index2++];
        }
        if (index1 != tempMiddle)
            System.arraycopy(temp, index1, array, index, tempMiddle - index1);
        if (index2 != toTemp)
            System.arraycopy(temp, index2, array, index, toTemp - index2);
    }

}

interface IntComparator {
    public static final IntComparator DEFAULT = new IntComparator() {
        public int compare(int first, int second) {
            if (first < second)
                return -1;
            if (first > second)
                return 1;
            return 0;
        }
    };

    public int compare(int first, int second);
}

/**
 * Created with IntelliJ IDEA.
 * User: zangetsu
 * Date: 9/1/13
 */

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.lang.reflect.Array;
import java.util.*;

public class Main_A {

    /**
     * @param args
     * @throws IOException
     */

    static InputReader scan = new InputReader(System.in);
    static PrintWriter pw = new PrintWriter(System.out);
    public static void main(String[] args) throws IOException {
        int r = scan.nextInt(), h = scan.nextInt();
        // compute //
        int ans = 0;

        if (h >= r / 2) {
            ans += h / r * 2;

            if (h%r >= (double) r / 2.0) {
                ans += 2;
            } else {
                ans += 1;
            }

        } else {
            ans = 0;
        }
        pw.println(ans);
        pw.close();
    }

}

class InputReader {

    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }
}

class ArrayUtils {
    private static int[] tempInt = new int[0];

    public static int[] sort(int[] array, IntComparator comparator) {
        return sort(array, 0, array.length, comparator);
    }

    public static int[] sort(int[] array, int from, int to,
                             IntComparator comparator) {
        ensureCapacityInt(to - from);
        System.arraycopy(array, from, tempInt, 0, to - from);
        sortImpl(array, from, to, tempInt, 0, to - from, comparator);
        return array;
    }

    private static void ensureCapacityInt(int size) {
        if (tempInt.length >= size)
            return;
        size = Math.max(size, tempInt.length << 1);
        tempInt = new int[size];
    }

    private static void sortImpl(int[] array, int from, int to, int[] temp,
                                 int fromTemp, int toTemp, IntComparator comparator) {
        if (to - from <= 1)
            return;
        int middle = (to - from) >> 1;
        int tempMiddle = fromTemp + middle;
        sortImpl(temp, fromTemp, tempMiddle, array, from, from + middle,
                comparator);
        sortImpl(temp, tempMiddle, toTemp, array, from + middle, to, comparator);
        int index = from;
        int index1 = fromTemp;
        int index2 = tempMiddle;
        while (index1 < tempMiddle && index2 < toTemp) {
            if (comparator.compare(temp[index1], temp[index2]) <= 0)
                array[index++] = temp[index1++];
            else
                array[index++] = temp[index2++];
        }
        if (index1 != tempMiddle)
            System.arraycopy(temp, index1, array, index, tempMiddle - index1);
        if (index2 != toTemp)
            System.arraycopy(temp, index2, array, index, toTemp - index2);
    }

}

interface IntComparator {
    public static final IntComparator DEFAULT = new IntComparator() {
        public int compare(int first, int second) {
            if (first < second)
                return -1;
            if (first > second)
                return 1;
            return 0;
        }
    };

    public int compare(int first, int second);
}

/**
 * Created with IntelliJ IDEA.
 * User: zangetsu
 * Date: 9/1/13
 */

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.lang.reflect.Array;
import java.util.*;

public class Main_A {

    /**
     * @param args
     * @throws IOException
     */

    static InputReader scan = new InputReader(System.in);
    static PrintWriter pw = new PrintWriter(System.out);
    public static void main(String[] args) throws IOException {
        int r = scan.nextInt(), h = scan.nextInt();
        // compute //
        int ans = 0;

        if (h >= r / 2) {
            ans += h / r * 2;

            if (h%r == 1) {
                ans += 2;
            } else {
                ans += 1;
            }

        } else {
            ans = 0;
        }
        pw.println(ans);
        pw.close();
    }

}

class InputReader {

    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }
}

class ArrayUtils {
    private static int[] tempInt = new int[0];

    public static int[] sort(int[] array, IntComparator comparator) {
        return sort(array, 0, array.length, comparator);
    }

    public static int[] sort(int[] array, int from, int to,
                             IntComparator comparator) {
        ensureCapacityInt(to - from);
        System.arraycopy(array, from, tempInt, 0, to - from);
        sortImpl(array, from, to, tempInt, 0, to - from, comparator);
        return array;
    }

    private static void ensureCapacityInt(int size) {
        if (tempInt.length >= size)
            return;
        size = Math.max(size, tempInt.length << 1);
        tempInt = new int[size];
    }

    private static void sortImpl(int[] array, int from, int to, int[] temp,
                                 int fromTemp, int toTemp, IntComparator comparator) {
        if (to - from <= 1)
            return;
        int middle = (to - from) >> 1;
        int tempMiddle = fromTemp + middle;
        sortImpl(temp, fromTemp, tempMiddle, array, from, from + middle,
                comparator);
        sortImpl(temp, tempMiddle, toTemp, array, from + middle, to, comparator);
        int index = from;
        int index1 = fromTemp;
        int index2 = tempMiddle;
        while (index1 < tempMiddle && index2 < toTemp) {
            if (comparator.compare(temp[index1], temp[index2]) <= 0)
                array[index++] = temp[index1++];
            else
                array[index++] = temp[index2++];
        }
        if (index1 != tempMiddle)
            System.arraycopy(temp, index1, array, index, tempMiddle - index1);
        if (index2 != toTemp)
            System.arraycopy(temp, index2, array, index, toTemp - index2);
    }

}

interface IntComparator {
    public static final IntComparator DEFAULT = new IntComparator() {
        public int compare(int first, int second) {
            if (first < second)
                return -1;
            if (first > second)
                return 1;
            return 0;
        }
    };

    public int compare(int first, int second);
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;

public class CupboardAndBalloons {
	public static void main(String[] args) {
		MyScanner sc = new MyScanner();

		int R = sc.nextInt();
		int H = sc.nextInt();

		int cbPart = H / R;
		int cbRemn = H % R;
		int tpPart = (cbRemn >= (R + 1) / 2) ? 2 : 1;

		System.out.println(2 * cbPart + tpPart);
	}

	public static class MyScanner {
		BufferedReader br;
		StringTokenizer st;

		public MyScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		String nextLine() {
			String str = "";
			try { str = br.readLine(); }
			catch (IOException e) { e.printStackTrace(); }
			return str;
		}
	}
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;

public class CupboardAndBalloons {
	public static void main(String[] args) {
		MyScanner sc = new MyScanner();

		int R = sc.nextInt();
		int H = sc.nextInt();

		int cbPart = H / R;
		int cbRemn = H % R;
		int tpPart = (cbRemn >= R) ? 2 : 1;

		System.out.println(2 * cbPart + tpPart);
	}

	public static class MyScanner {
		BufferedReader br;
		StringTokenizer st;

		public MyScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		String nextLine() {
			String str = "";
			try { str = br.readLine(); }
			catch (IOException e) { e.printStackTrace(); }
			return str;
		}
	}
}

import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.math.*;
import java.net.*;

public class Task{
    public static void main(String[] args) throws IOException{
        new Task().run();
    }

    StreamTokenizer in;
    Scanner ins;
    PrintWriter out;

    int nextInt() throws IOException{
        in.nextToken();
        return (int)in.nval;
    }

    long nextLong() throws IOException{
        in.nextToken();
        return (long)in.nval;
    }

    double nextDouble() throws IOException{
        in.nextToken();
        return in.nval;
    }

    char nextChar() throws IOException{
        in.nextToken();
        return (char)in.ttype;
    }

    String nextString() throws IOException{
        in.nextToken();
        return in.sval;
    }

    long gcdLight(long a, long b){
        a = Math.abs(a);
        b = Math.abs(b);
        while(a != 0 && b != 0){
            if(a > b)
                a %= b;
            else
                b %= a;
        }
        return a + b;
    }

    Task.ForGCD gcd(int a,int b){
        Task.ForGCD tmp = new Task.ForGCD();
        if(a == 0){
            tmp.x = 0;
            tmp.y = 1;
            tmp.d = b;
        }else{
            Task.ForGCD tmp1 = gcd(b%a, a);
            tmp.d = tmp1.d;
            tmp.y = tmp1.x;
            tmp.x = tmp1.y - tmp1.x*(b/a);
        }
        return tmp;
    }

    void run() throws IOException{
        in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        ins = new Scanner(System.in);
        out = new PrintWriter(System.out);
        try{
            if(System.getProperty("xDx")!=null){
                in = new StreamTokenizer(new BufferedReader(new FileReader("input.txt")));
                ins = new Scanner(new FileReader("input.txt"));
                out = new PrintWriter(new FileWriter("output.txt"));
            }
        }catch(Exception e){

        }

        long r = nextInt(), h = nextInt();
        long res = h/r * 2;
        if((h%r)*2 >= r){
            res += 2;
            long p1 = 3*r;
            p1 *= r;
            long p2 = 4*(h%r) - 2*r;
            p2 = p2*p2;
            if(p2 >= p1){
                res++;
            }
        }else{
            res++;
        }
        out.print(res);

        out.close();
    }

    class ForGCD{
        int x,y,d;
    }

    class Boxes implements Comparable{
        public long k,a;
        public Boxes(long k, long a){
            this.k = k;
            this.a = a;
        }

        public int compareTo(Object obj){
            Task.Boxes b = (Task.Boxes) obj;
            if(k < b.k)
                return -1;
            else
                if(k == b.k)
                    return 0;
                else
                    return 1;
        }
    }
}

import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.math.*;
import java.net.*;

public class Task{
    public static void main(String[] args) throws IOException{
        new Task().run();
    }

    StreamTokenizer in;
    Scanner ins;
    PrintWriter out;

    int nextInt() throws IOException{
        in.nextToken();
        return (int)in.nval;
    }

    long nextLong() throws IOException{
        in.nextToken();
        return (long)in.nval;
    }

    double nextDouble() throws IOException{
        in.nextToken();
        return in.nval;
    }

    char nextChar() throws IOException{
        in.nextToken();
        return (char)in.ttype;
    }

    String nextString() throws IOException{
        in.nextToken();
        return in.sval;
    }

    long gcdLight(long a, long b){
        a = Math.abs(a);
        b = Math.abs(b);
        while(a != 0 && b != 0){
            if(a > b)
                a %= b;
            else
                b %= a;
        }
        return a + b;
    }

    Task.ForGCD gcd(int a,int b){
        Task.ForGCD tmp = new Task.ForGCD();
        if(a == 0){
            tmp.x = 0;
            tmp.y = 1;
            tmp.d = b;
        }else{
            Task.ForGCD tmp1 = gcd(b%a, a);
            tmp.d = tmp1.d;
            tmp.y = tmp1.x;
            tmp.x = tmp1.y - tmp1.x*(b/a);
        }
        return tmp;
    }

    void run() throws IOException{
        in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        ins = new Scanner(System.in);
        out = new PrintWriter(System.out);
        try{
            if(System.getProperty("xDx")!=null){
                in = new StreamTokenizer(new BufferedReader(new FileReader("input.txt")));
                ins = new Scanner(new FileReader("input.txt"));
                out = new PrintWriter(new FileWriter("output.txt"));
            }
        }catch(Exception e){

        }

        long r = nextInt(), h = nextInt();
        long res = h/r * 2;
        if((h%r)*2 >= r){
            res += 2;
            long p1 = 3*r;
            p1 *= r;
            long p2 = 4*(h/r) - 2*r;
            p2 = p2*p2;
            if(p2 >= p1){
                res++;
            }
        }else{
            res++;
        }
        out.print(res);

        out.close();
    }

    class ForGCD{
        int x,y,d;
    }

    class Boxes implements Comparable{
        public long k,a;
        public Boxes(long k, long a){
            this.k = k;
            this.a = a;
        }

        public int compareTo(Object obj){
            Task.Boxes b = (Task.Boxes) obj;
            if(k < b.k)
                return -1;
            else
                if(k == b.k)
                    return 0;
                else
                    return 1;
        }
    }
}

import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.math.*;
import java.net.*;

public class Task{
    public static void main(String[] args) throws IOException{
        new Task().run();
    }

    StreamTokenizer in;
    Scanner ins;
    PrintWriter out;

    int nextInt() throws IOException{
        in.nextToken();
        return (int)in.nval;
    }

    long nextLong() throws IOException{
        in.nextToken();
        return (long)in.nval;
    }

    double nextDouble() throws IOException{
        in.nextToken();
        return in.nval;
    }

    char nextChar() throws IOException{
        in.nextToken();
        return (char)in.ttype;
    }

    String nextString() throws IOException{
        in.nextToken();
        return in.sval;
    }

    long gcdLight(long a, long b){
        a = Math.abs(a);
        b = Math.abs(b);
        while(a != 0 && b != 0){
            if(a > b)
                a %= b;
            else
                b %= a;
        }
        return a + b;
    }

    Task.ForGCD gcd(int a,int b){
        Task.ForGCD tmp = new Task.ForGCD();
        if(a == 0){
            tmp.x = 0;
            tmp.y = 1;
            tmp.d = b;
        }else{
            Task.ForGCD tmp1 = gcd(b%a, a);
            tmp.d = tmp1.d;
            tmp.y = tmp1.x;
            tmp.x = tmp1.y - tmp1.x*(b/a);
        }
        return tmp;
    }

    void run() throws IOException{
        in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        ins = new Scanner(System.in);
        out = new PrintWriter(System.out);
        try{
            if(System.getProperty("xDx")!=null){
                in = new StreamTokenizer(new BufferedReader(new FileReader("input.txt")));
                ins = new Scanner(new FileReader("input.txt"));
                out = new PrintWriter(new FileWriter("output.txt"));
            }
        }catch(Exception e){

        }

        int r = nextInt(), h = nextInt();
        int res = h/r * 2;
        if((h%r)*2 >= r){
            res += 2;
            long p1 = 3*r;
            p1 *= r;
            long p2 = 2*(h/r) - r;
            p2 = p2*p2;
            if(p2 >= p1){
                res++;
            }
        }else{
            res++;
        }
        out.print(res);

        out.close();
    }

    class ForGCD{
        int x,y,d;
    }

    class Boxes implements Comparable{
        public long k,a;
        public Boxes(long k, long a){
            this.k = k;
            this.a = a;
        }

        public int compareTo(Object obj){
            Task.Boxes b = (Task.Boxes) obj;
            if(k < b.k)
                return -1;
            else
                if(k == b.k)
                    return 0;
                else
                    return 1;
        }
    }
}

import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.math.*;
import java.net.*;

public class Task{
    public static void main(String[] args) throws IOException{
        new Task().run();
    }

    StreamTokenizer in;
    Scanner ins;
    PrintWriter out;

    int nextInt() throws IOException{
        in.nextToken();
        return (int)in.nval;
    }

    long nextLong() throws IOException{
        in.nextToken();
        return (long)in.nval;
    }

    double nextDouble() throws IOException{
        in.nextToken();
        return in.nval;
    }

    char nextChar() throws IOException{
        in.nextToken();
        return (char)in.ttype;
    }

    String nextString() throws IOException{
        in.nextToken();
        return in.sval;
    }

    long gcdLight(long a, long b){
        a = Math.abs(a);
        b = Math.abs(b);
        while(a != 0 && b != 0){
            if(a > b)
                a %= b;
            else
                b %= a;
        }
        return a + b;
    }

    Task.ForGCD gcd(int a,int b){
        Task.ForGCD tmp = new Task.ForGCD();
        if(a == 0){
            tmp.x = 0;
            tmp.y = 1;
            tmp.d = b;
        }else{
            Task.ForGCD tmp1 = gcd(b%a, a);
            tmp.d = tmp1.d;
            tmp.y = tmp1.x;
            tmp.x = tmp1.y - tmp1.x*(b/a);
        }
        return tmp;
    }

    void run() throws IOException{
        in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        ins = new Scanner(System.in);
        out = new PrintWriter(System.out);
        try{
            if(System.getProperty("xDx")!=null){
                in = new StreamTokenizer(new BufferedReader(new FileReader("input.txt")));
                ins = new Scanner(new FileReader("input.txt"));
                out = new PrintWriter(new FileWriter("output.txt"));
            }
        }catch(Exception e){

        }

        int r = nextInt(), h = nextInt();
        int res = h/r * 2 + 1;
        if((h%r)*2 >= r){
            res++;
        }
        out.print(res);

        out.close();
    }

    class ForGCD{
        int x,y,d;
    }

    class Boxes implements Comparable{
        public long k,a;
        public Boxes(long k, long a){
            this.k = k;
            this.a = a;
        }

        public int compareTo(Object obj){
            Task.Boxes b = (Task.Boxes) obj;
            if(k < b.k)
                return -1;
            else
                if(k == b.k)
                    return 0;
                else
                    return 1;
        }
    }
}

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class Main
{

	private static BufferedReader in;
	private static BufferedWriter out;

	public static void main(String... args) throws IOException
	{
		// streams
		boolean file = false;
		if (file)
			in = new BufferedReader(new FileReader("input.txt"));
		else
			in = new BufferedReader(new InputStreamReader(System.in));
		out = new BufferedWriter(new OutputStreamWriter(System.out));
		StringTokenizer tok;

		// take input
		tok = new StringTokenizer(in.readLine());
		int r = Integer.parseInt(tok.nextToken());
		int h = Integer.parseInt(tok.nextToken());

		// make levels of two
		long sum = 0;
		long levels = (r/2 + h) / r;
		sum += levels*2;

		// last one
		long height = levels *r;
		if (height == h)
			sum ++;
		System.out.println(sum);
		out.flush();
	}

}

import java.io.*;
import java.util.*;

public class Solution {
    public static void main(String[] args) throws IOException {
        Solution sol = new Solution();
        sol.run();
    }

    final double EPS = 1e-9;

    double sqr(double a) {
        return a * a;
    }

    double dist2(double ax, double ay, double bx, double by) {
        return sqr(ax - bx) + sqr(ay - by);
    }

    boolean inside(double r, double h, double cx, double cy) {
        double p = r / 2;
        if (cy - p < -EPS)
            return false;
        if (cy + p > h + r + EPS)
            return false;
        if (cx - p < -EPS)
            return false;
        if (cx + p > 2 * r + EPS)
            return false;
        if (cy + p > h + EPS)
            return dist2(r, h, cx, cy) < sqr(p) + EPS;
        return true;
    }

    void run() throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stok = new StringTokenizer(reader.readLine());
        int r = Integer.parseInt(stok.nextToken());
        int h = Integer.parseInt(stok.nextToken());
        int lf = 0, rg = (r + h) / r + 1;
        double cx = r / 2.0;
        while (lf + 1 < rg) {
            int mid = (lf + rg) / 2;
            double cy = r * (mid + 0.5);
            if (inside(r, h, cx, cy))
                lf = mid;
            else
                rg = mid;
        }
        for (; rg >= lf; --rg) {
            double cy = r * (rg + 0.5);
            if (inside(r, h, cx, cy))
                break;
        }
        int ans = 0;
        if (rg >= lf)
            ans += 2 * (rg + 1);
        cx = r;
        double cy = r / 2.0;
        if (rg >= lf)
            cy = r * (rg + 0.5 + Math.sqrt(0.75));
        if (inside(r, h, cx, cy))
            ++ans;
        System.out.println(ans);
    }
}

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class Main
{

    private static BufferedReader in;
    private static BufferedWriter out;

    public static void main(String... args) throws IOException
    {
        // streams
        boolean file = false;
        if (file)
            in = new BufferedReader(new FileReader("input.txt"));
        else
            in = new BufferedReader(new InputStreamReader(System.in));
        out = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer tok;

        // take input
        tok = new StringTokenizer(in.readLine());
        int r = Integer.parseInt(tok.nextToken());
        int h = Integer.parseInt(tok.nextToken());

        // make levels of two
        long sum = 0;
        long levels = (r/2 + h) / r;
        sum += levels*2;

        // last one
        long height = levels *r;
        if (height <= h)
            sum ++;
        System.out.println(sum);
        out.flush();
    }

}

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class Main
{

    private static BufferedReader in;
    private static BufferedWriter out;

    public static void main(String... args) throws IOException
    {
        // streams
        boolean file = false;
        if (file)
            in = new BufferedReader(new FileReader("input.txt"));
        else
            in = new BufferedReader(new InputStreamReader(System.in));
        out = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer tok;

        // take input
        tok = new StringTokenizer(in.readLine());
        int r = Integer.parseInt(tok.nextToken());
        int h = Integer.parseInt(tok.nextToken());

        // make levels of two
        long sum = 0;
        long levels = (r/2 + h) / r;
        sum += levels*2;

        // last one
        long height = levels *r;
        if (height == h)
            sum ++;
        System.out.println(sum);
        out.flush();
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Y {

	public static void main(String[] args) throws Exception{
		Scanner sc = new Scanner(System.in);

		int r = sc.nextInt();
		int h = sc.nextInt();

		int rem = h % r ;

		System.out.println( 2*(h/r)+ ( 4*rem>= 3*h ? 3 : 2*rem>=r ? 2 : 1) );

	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}

}

import java.io.*;
import java.util.*;
public class cupboard_balloons
{
	public static void main(String args[])
	{
		InputReader in = new InputReader(System.in);
		OutputStream outputStream = System.out;
		PrintWriter out = new PrintWriter(outputStream);
		/*------------------------------My Code starts here------------------------------*/
		int r=in.nextInt(),h=in.nextInt(),ans=0;
		ans+=(h/r)*2;
//		out.println(ans);
		if(h%r>=r/2.0)
			ans+=2;
		else
			ans+=1;
		out.println(ans);
		out.close();
		/*------------------------------The End------------------------------------------*/
	}
	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader(InputStream inputstream) {
			reader = new BufferedReader(new InputStreamReader(inputstream));
			tokenizer = null;
		}

		public String nextLine(){
			String fullLine=null;
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					fullLine=reader.readLine();
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
				return fullLine;
			}
			return fullLine;
		}
		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}
		public long nextLong() {
			return Long.parseLong(next());
		}
		public int nextInt() {
			return Integer.parseInt(next());
		}
	}
}

import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class Main extends PrintWriter {
    final Random rand = new Random(31);
    final int inf = (int) 1e9;
    final long linf = (long) 1e18;

    final static String IO = "_std";

    double dist(double x1, double y1, double x2, double y2) {
        return sqrt((x1 - x2 ) * (x1 - x2) + (y1 - y2) * (y1 - y2));
    }

    void solve() throws IOException {
        int r = nextInt();
        int h = nextInt();

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

        double d = dist(0, h + r / 2.0, r / 4.0, 1.0 * x * r - r / 2.0);

        if (d > r - 1e-9) {
            println(2 * x + 1);
        } else {
            println(2 * x);
        }
    }

    BufferedReader in;
    StringTokenizer stok;

    Main() {
        super(System.out);
        in = new BufferedReader(new InputStreamReader(System.in));
    }

    Main(String fileIn, String fileOut) throws IOException {
        super(fileOut);
        in = new BufferedReader(new FileReader(fileIn));
    }

    public static void main(String[] args) throws IOException {
        Main main;
        if ("_std".equals(IO)) {
            main = new Main();
        } else if ("_iotxt".equals(IO)) {
            main = new Main("input.txt", "output.txt");
        } else {
            main = new Main(IO + ".in", IO + ".out");
        }
        main.solve();
        main.close();
    }

    String next() throws IOException {
        while (stok == null || !stok.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null) {
                return null;
            }
            stok = new StringTokenizer(s);
        }
        return stok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    int[] nextIntArray(int len) throws IOException {
        int[] a = new int[len];
        for (int i = 0; i < len; i++) {
            a[i] = nextInt();
        }
        return a;
    }

    int[] nextIntArraySorted(int len) throws IOException {
        int[] a = nextIntArray(len);
        shuffle(a);
        Arrays.sort(a);
        return a;
    }

    void shuffle(int[] a) {
        for (int i = 1; i < a.length; i++) {
            int x = rand.nextInt(i + 1);
            int _ = a[i];
            a[i] = a[x];
            a[x] = _;
        }
    }

    void shuffleAndSort(int[] a) {
        shuffle(a);
        Arrays.sort(a);
    }

    boolean nextPermutation(int[] p) {
        for (int a = p.length - 2; a >= 0; --a) {
            if (p[a] < p[a + 1])
                for (int b = p.length - 1; ; --b)
                    if (p[b] > p[a]) {
                        int t = p[a];
                        p[a] = p[b];
                        p[b] = t;
                        for (++a, b = p.length - 1; a < b; ++a, --b) {
                            t = p[a];
                            p[a] = p[b];
                            p[b] = t;
                        }
                        return true;
                    }
        }
        return false;
    }

    <T> List<T>[] createAdjacencyList(int n) {
        List<T>[] res = new List[n];
        for (int i = 0; i < n; i++) {
            res[i] = new ArrayList<>();
        }
        return res;
    }

    void println(Object... a) {
        for (int i = 0; i < a.length; i++) {
            if (i != 0) {
                print(" ");
            }
            print(a[i]);
        }
        println();
    }
}

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Solution {
    private IO io;
    private int ioMode = -1;
    private String problemName = "";
    private final String mjArgument = "master_j";

    public static void main(String programArguments[]) throws IOException{
        if(programArguments != null && programArguments.length > 0)
            new Solution().run(programArguments[0]);
        else
            new Solution().run(null);
    }

    private void run(String programArgument) throws IOException {
        //         _______________________________________________ _________
        //        |   Input Mode     |      Output Mode    | mode | comment |
        //        |------------------|---------------------|----- |---------|
        //        |   input.txt      |      System.out     |  0   |    mj   |
        //        |   System.in      |      System.out     |  1   |  T / CF |
        //        |<problemName>.in  |  <problemName>.out  |  2   |         |
        //        |   input.txt      |      output.txt     |  3   |    C    |
        //        |__________________|_____________________|______|_________|
        long nanoTime = 0;
        if(programArgument != null && programArgument.equals(mjArgument)) // mj
            ioMode = 0;
        else if(System.getProperty("ONLINE_JUDGE") != null) // T / CF
            ioMode = 1;
        else
            ioMode = 2;
        switch(ioMode){
            case -1:
                try{
                    throw new Exception("<ioMode> init failure") ;
                }catch (Exception e){
                    e.printStackTrace();
                }
                return;
            case 0:
                break;
            case 1:
                break;
            case 2:
                if(problemName.length() == 0){
                    try{
                        throw new Exception("<problemName> init failure");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return;
                }
            case 3:
                break;
        }
        io = new IO(ioMode, problemName);
        if(ioMode == 0){
            System.out.println("File output : \n<start>");
            System.out.flush();
            nanoTime = System.nanoTime();
        }
        solve();
        io.flush();
        if(ioMode == 0){
            System.out.println("</start>");
            long t = System.nanoTime() - nanoTime;
            int d3 = 1000000000, d2 = 1000000, d1 = 1000;
            if(t>=d3)
                System.out.println(t/d3 + "." + t%d3 + " seconds");
            else if(t>=d2)
                System.out.println(t/d2 + "." + t%d2 + " millis");
            else if(t>=d1)
                System.out.println(t/d1 + "." + t%d1 + " micros");
            else
                System.out.println(t + " nanos");
            System.out.flush();
        }
    }

    private void solve() throws IOException {
        long r = io.nI(), h = io.nI(), ans = 0;
        ans += h/r*2;
        h %= r;
        double t = 0;
        if(h >= r/2.0)
            ans += 2;
        else{
            t -= r;
        }
        double r_2 = r/2.0;
        if(r*r <= dist_2(r_2, r_2, r_2-t, r_2, r, h-r_2))
            ans += 1;
        io.wln(ans);
    }//2.2250738585072012e-308

    double dist_2(double x1, double y1, double z1, double x2, double y2, double z2){
        double d = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) + (z1-z2)*(z1-z2);
        return d;
    }

    /**
     * Input-output class
     * @author master_j
     * @version 0.2.5
     */
    @SuppressWarnings("unused")
    private class IO{
        private boolean alwaysFlush;
        StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
        public IO(int ioMode, String problemName) throws IOException{
            Locale.setDefault(Locale.US);
            //         _______________________________________________ _________
            //        |   Input Mode     |      Output Mode    | mode | comment |
            //        |------------------|---------------------|----- |---------|
            //        |   input.txt      |      System.out     |  0   |    mj   |
            //        |   System.in      |      System.out     |  1   |  T / CF |
            //        |<problemName>.in  |  <problemName>.out  |  2   |         |
            //        |   input.txt      |      output.txt     |  3   |    C    |
            //        |__________________|_____________________|______|_________|
            switch(ioMode){
                case 0:
                    reader = new FileReader("input.txt");
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 1:
                    reader = new InputStreamReader(System.in);
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 2:
                    reader = new FileReader(problemName + ".in");
                    writer = new FileWriter(problemName + ".out");
                    break;
                case 3:
                    reader = new FileReader("input.txt");
                    writer = new FileWriter("output.txt");
                    break;
            }
            br = new BufferedReader(reader);
            in = new StreamTokenizer(br);
            out = new PrintWriter(writer);
            alwaysFlush = false;
        }
        public void setAlwaysFlush(boolean arg){alwaysFlush = arg;}
        public void wln(){out.println(); if(alwaysFlush)flush();}
        public void wln(int arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(long arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(double arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(String arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(boolean arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(char arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(float arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(Object arg){out.println(arg); if(alwaysFlush)flush();}
        public void w(int arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(long arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(double arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(String arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(boolean arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(char arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(float arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(Object arg){out.print(arg); if(alwaysFlush)flush();}
        public void wf(String format, Object...args){out.printf(format, args); if(alwaysFlush)flush();}
        public void flush(){out.flush();}
        public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
        public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
        public String nS() throws IOException {in.nextToken(); return in.sval;}
        public double nD() throws IOException {in.nextToken(); return in.nval;}
        public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
        public char nC() throws IOException {return (char)br.read();}
        public void wc(char...arg){for(char c : arg){in.ordinaryChar(c);in.wordChars(c, c);}}
        public void wc(String arg){wc(arg.toCharArray());}
        public void wc(char arg0, char arg1){in.ordinaryChars(arg0, arg1); in.wordChars(arg0, arg1);}
        public boolean eof(){return in.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol(){return in.ttype == StreamTokenizer.TT_EOL;}
    }
}

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Solution {
    private IO io;
    private int ioMode = -1;
    private String problemName = "";
    private final String mjArgument = "master_j";

    public static void main(String programArguments[]) throws IOException{
        if(programArguments != null && programArguments.length > 0)
            new Solution().run(programArguments[0]);
        else
            new Solution().run(null);
    }

    private void run(String programArgument) throws IOException {
        //         _______________________________________________ _________
        //        |   Input Mode     |      Output Mode    | mode | comment |
        //        |------------------|---------------------|----- |---------|
        //        |   input.txt      |      System.out     |  0   |    mj   |
        //        |   System.in      |      System.out     |  1   |  T / CF |
        //        |<problemName>.in  |  <problemName>.out  |  2   |         |
        //        |   input.txt      |      output.txt     |  3   |    C    |
        //        |__________________|_____________________|______|_________|
        long nanoTime = 0;
        if(programArgument != null && programArgument.equals(mjArgument)) // mj
            ioMode = 0;
        else if(System.getProperty("ONLINE_JUDGE") != null) // T / CF
            ioMode = 1;
        else
            ioMode = 2;
        switch(ioMode){
            case -1:
                try{
                    throw new Exception("<ioMode> init failure") ;
                }catch (Exception e){
                    e.printStackTrace();
                }
                return;
            case 0:
                break;
            case 1:
                break;
            case 2:
                if(problemName.length() == 0){
                    try{
                        throw new Exception("<problemName> init failure");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return;
                }
            case 3:
                break;
        }
        io = new IO(ioMode, problemName);
        if(ioMode == 0){
            System.out.println("File output : \n<start>");
            System.out.flush();
            nanoTime = System.nanoTime();
        }
        solve();
        io.flush();
        if(ioMode == 0){
            System.out.println("</start>");
            long t = System.nanoTime() - nanoTime;
            int d3 = 1000000000, d2 = 1000000, d1 = 1000;
            if(t>=d3)
                System.out.println(t/d3 + "." + t%d3 + " seconds");
            else if(t>=d2)
                System.out.println(t/d2 + "." + t%d2 + " millis");
            else if(t>=d1)
                System.out.println(t/d1 + "." + t%d1 + " micros");
            else
                System.out.println(t + " nanos");
            System.out.flush();
        }
    }

    private void solve() throws IOException {
        int r = io.nI(), h = io.nI(), ans = 0;
        ans += h/r*2;
        h %= r;
        double t = 0;
        if(h >= r/2.0)
            ans += 2;
        else{
            t -= r;
        }
        double r_2 = r/2.0;
        if(r*r <= dist_2(r_2, r_2, r_2-t, r_2, r, h+r_2))
            ans += 1;
        io.wln(ans);
    }//2.2250738585072012e-308

    double dist_2(double x1, double y1, double z1, double x2, double y2, double z2){
        double d = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) + (z1-z2)*(z1-z2);
        return d;
    }

    /**
     * Input-output class
     * @author master_j
     * @version 0.2.5
     */
    @SuppressWarnings("unused")
    private class IO{
        private boolean alwaysFlush;
        StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
        public IO(int ioMode, String problemName) throws IOException{
            Locale.setDefault(Locale.US);
            //         _______________________________________________ _________
            //        |   Input Mode     |      Output Mode    | mode | comment |
            //        |------------------|---------------------|----- |---------|
            //        |   input.txt      |      System.out     |  0   |    mj   |
            //        |   System.in      |      System.out     |  1   |  T / CF |
            //        |<problemName>.in  |  <problemName>.out  |  2   |         |
            //        |   input.txt      |      output.txt     |  3   |    C    |
            //        |__________________|_____________________|______|_________|
            switch(ioMode){
                case 0:
                    reader = new FileReader("input.txt");
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 1:
                    reader = new InputStreamReader(System.in);
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 2:
                    reader = new FileReader(problemName + ".in");
                    writer = new FileWriter(problemName + ".out");
                    break;
                case 3:
                    reader = new FileReader("input.txt");
                    writer = new FileWriter("output.txt");
                    break;
            }
            br = new BufferedReader(reader);
            in = new StreamTokenizer(br);
            out = new PrintWriter(writer);
            alwaysFlush = false;
        }
        public void setAlwaysFlush(boolean arg){alwaysFlush = arg;}
        public void wln(){out.println(); if(alwaysFlush)flush();}
        public void wln(int arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(long arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(double arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(String arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(boolean arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(char arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(float arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(Object arg){out.println(arg); if(alwaysFlush)flush();}
        public void w(int arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(long arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(double arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(String arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(boolean arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(char arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(float arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(Object arg){out.print(arg); if(alwaysFlush)flush();}
        public void wf(String format, Object...args){out.printf(format, args); if(alwaysFlush)flush();}
        public void flush(){out.flush();}
        public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
        public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
        public String nS() throws IOException {in.nextToken(); return in.sval;}
        public double nD() throws IOException {in.nextToken(); return in.nval;}
        public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
        public char nC() throws IOException {return (char)br.read();}
        public void wc(char...arg){for(char c : arg){in.ordinaryChar(c);in.wordChars(c, c);}}
        public void wc(String arg){wc(arg.toCharArray());}
        public void wc(char arg0, char arg1){in.ordinaryChars(arg0, arg1); in.wordChars(arg0, arg1);}
        public boolean eof(){return in.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol(){return in.ttype == StreamTokenizer.TT_EOL;}
    }
}

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Solution {
    private IO io;
    private int ioMode = -1;
    private String problemName = "";
    private final String mjArgument = "master_j";

    public static void main(String programArguments[]) throws IOException{
        if(programArguments != null && programArguments.length > 0)
            new Solution().run(programArguments[0]);
        else
            new Solution().run(null);
    }

    private void run(String programArgument) throws IOException {
        //         _______________________________________________ _________
        //        |   Input Mode     |      Output Mode    | mode | comment |
        //        |------------------|---------------------|----- |---------|
        //        |   input.txt      |      System.out     |  0   |    mj   |
        //        |   System.in      |      System.out     |  1   |  T / CF |
        //        |<problemName>.in  |  <problemName>.out  |  2   |         |
        //        |   input.txt      |      output.txt     |  3   |    C    |
        //        |__________________|_____________________|______|_________|
        long nanoTime = 0;
        if(programArgument != null && programArgument.equals(mjArgument)) // mj
            ioMode = 0;
        else if(System.getProperty("ONLINE_JUDGE") != null) // T / CF
            ioMode = 1;
        else
            ioMode = 2;
        switch(ioMode){
            case -1:
                try{
                    throw new Exception("<ioMode> init failure") ;
                }catch (Exception e){
                    e.printStackTrace();
                }
                return;
            case 0:
                break;
            case 1:
                break;
            case 2:
                if(problemName.length() == 0){
                    try{
                        throw new Exception("<problemName> init failure");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return;
                }
            case 3:
                break;
        }
        io = new IO(ioMode, problemName);
        if(ioMode == 0){
            System.out.println("File output : \n<start>");
            System.out.flush();
            nanoTime = System.nanoTime();
        }
        solve();
        io.flush();
        if(ioMode == 0){
            System.out.println("</start>");
            long t = System.nanoTime() - nanoTime;
            int d3 = 1000000000, d2 = 1000000, d1 = 1000;
            if(t>=d3)
                System.out.println(t/d3 + "." + t%d3 + " seconds");
            else if(t>=d2)
                System.out.println(t/d2 + "." + t%d2 + " millis");
            else if(t>=d1)
                System.out.println(t/d1 + "." + t%d1 + " micros");
            else
                System.out.println(t + " nanos");
            System.out.flush();
        }
    }

    private void solve() throws IOException {
        int r = io.nI(), h = io.nI(), ans = 0;
        ans += h/r; ans *= 2;
        h %= r;
        double r_2 = r/2.0;
        if(h >= r/2.0)
            ans += 2;
        else if(r*r <= dist_2(r_2, r_2, r_2, r_2, r, h-r_2))
            ans += 1;
        io.wln(ans);
    }//2.2250738585072012e-308

    double dist_2(double x1, double y1, double z1, double x2, double y2, double z2){
        double d = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) + (z1-z2)*(z1-z2);
        return d;
    }

    /**
     * Input-output class
     * @author master_j
     * @version 0.2.5
     */
    @SuppressWarnings("unused")
    private class IO{
        private boolean alwaysFlush;
        StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
        public IO(int ioMode, String problemName) throws IOException{
            Locale.setDefault(Locale.US);
            //         _______________________________________________ _________
            //        |   Input Mode     |      Output Mode    | mode | comment |
            //        |------------------|---------------------|----- |---------|
            //        |   input.txt      |      System.out     |  0   |    mj   |
            //        |   System.in      |      System.out     |  1   |  T / CF |
            //        |<problemName>.in  |  <problemName>.out  |  2   |         |
            //        |   input.txt      |      output.txt     |  3   |    C    |
            //        |__________________|_____________________|______|_________|
            switch(ioMode){
                case 0:
                    reader = new FileReader("input.txt");
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 1:
                    reader = new InputStreamReader(System.in);
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 2:
                    reader = new FileReader(problemName + ".in");
                    writer = new FileWriter(problemName + ".out");
                    break;
                case 3:
                    reader = new FileReader("input.txt");
                    writer = new FileWriter("output.txt");
                    break;
            }
            br = new BufferedReader(reader);
            in = new StreamTokenizer(br);
            out = new PrintWriter(writer);
            alwaysFlush = false;
        }
        public void setAlwaysFlush(boolean arg){alwaysFlush = arg;}
        public void wln(){out.println(); if(alwaysFlush)flush();}
        public void wln(int arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(long arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(double arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(String arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(boolean arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(char arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(float arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(Object arg){out.println(arg); if(alwaysFlush)flush();}
        public void w(int arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(long arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(double arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(String arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(boolean arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(char arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(float arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(Object arg){out.print(arg); if(alwaysFlush)flush();}
        public void wf(String format, Object...args){out.printf(format, args); if(alwaysFlush)flush();}
        public void flush(){out.flush();}
        public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
        public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
        public String nS() throws IOException {in.nextToken(); return in.sval;}
        public double nD() throws IOException {in.nextToken(); return in.nval;}
        public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
        public char nC() throws IOException {return (char)br.read();}
        public void wc(char...arg){for(char c : arg){in.ordinaryChar(c);in.wordChars(c, c);}}
        public void wc(String arg){wc(arg.toCharArray());}
        public void wc(char arg0, char arg1){in.ordinaryChars(arg0, arg1); in.wordChars(arg0, arg1);}
        public boolean eof(){return in.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol(){return in.ttype == StreamTokenizer.TT_EOL;}
    }
}

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Solution {
    private IO io;
    private int ioMode = -1;
    private String problemName = "";
    private final String mjArgument = "master_j";

    public static void main(String programArguments[]) throws IOException{
        if(programArguments != null && programArguments.length > 0)
            new Solution().run(programArguments[0]);
        else
            new Solution().run(null);
    }

    private void run(String programArgument) throws IOException {
        //         _______________________________________________ _________
        //        |   Input Mode     |      Output Mode    | mode | comment |
        //        |------------------|---------------------|----- |---------|
        //        |   input.txt      |      System.out     |  0   |    mj   |
        //        |   System.in      |      System.out     |  1   |  T / CF |
        //        |<problemName>.in  |  <problemName>.out  |  2   |         |
        //        |   input.txt      |      output.txt     |  3   |    C    |
        //        |__________________|_____________________|______|_________|
        long nanoTime = 0;
        if(programArgument != null && programArgument.equals(mjArgument)) // mj
            ioMode = 0;
        else if(System.getProperty("ONLINE_JUDGE") != null) // T / CF
            ioMode = 1;
        else
            ioMode = 2;
        switch(ioMode){
            case -1:
                try{
                    throw new Exception("<ioMode> init failure") ;
                }catch (Exception e){
                    e.printStackTrace();
                }
                return;
            case 0:
                break;
            case 1:
                break;
            case 2:
                if(problemName.length() == 0){
                    try{
                        throw new Exception("<problemName> init failure");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return;
                }
            case 3:
                break;
        }
        io = new IO(ioMode, problemName);
        if(ioMode == 0){
            System.out.println("File output : \n<start>");
            System.out.flush();
            nanoTime = System.nanoTime();
        }
        solve();
        io.flush();
        if(ioMode == 0){
            System.out.println("</start>");
            long t = System.nanoTime() - nanoTime;
            int d3 = 1000000000, d2 = 1000000, d1 = 1000;
            if(t>=d3)
                System.out.println(t/d3 + "." + t%d3 + " seconds");
            else if(t>=d2)
                System.out.println(t/d2 + "." + t%d2 + " millis");
            else if(t>=d1)
                System.out.println(t/d1 + "." + t%d1 + " micros");
            else
                System.out.println(t + " nanos");
            System.out.flush();
        }
    }

    private void solve() throws IOException {
        int r = io.nI(), h = io.nI(), ans = 0;
        ans += h/r*2;
        h %= r;
        if(h >= r/2.0){
            ans += 2;
            //h -= r;
        }
        double r_2 = r/2.0;
        if(r*r <= dist_2(r_2, r_2, r_2, r_2, r, h-r_2))
            ans += 1;
        io.wln(ans);
    }//2.2250738585072012e-308

    double dist_2(double x1, double y1, double z1, double x2, double y2, double z2){
        double d = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) + (z1-z2)*(z1-z2);
        return d;
    }

    /**
     * Input-output class
     * @author master_j
     * @version 0.2.5
     */
    @SuppressWarnings("unused")
    private class IO{
        private boolean alwaysFlush;
        StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
        public IO(int ioMode, String problemName) throws IOException{
            Locale.setDefault(Locale.US);
            //         _______________________________________________ _________
            //        |   Input Mode     |      Output Mode    | mode | comment |
            //        |------------------|---------------------|----- |---------|
            //        |   input.txt      |      System.out     |  0   |    mj   |
            //        |   System.in      |      System.out     |  1   |  T / CF |
            //        |<problemName>.in  |  <problemName>.out  |  2   |         |
            //        |   input.txt      |      output.txt     |  3   |    C    |
            //        |__________________|_____________________|______|_________|
            switch(ioMode){
                case 0:
                    reader = new FileReader("input.txt");
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 1:
                    reader = new InputStreamReader(System.in);
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 2:
                    reader = new FileReader(problemName + ".in");
                    writer = new FileWriter(problemName + ".out");
                    break;
                case 3:
                    reader = new FileReader("input.txt");
                    writer = new FileWriter("output.txt");
                    break;
            }
            br = new BufferedReader(reader);
            in = new StreamTokenizer(br);
            out = new PrintWriter(writer);
            alwaysFlush = false;
        }
        public void setAlwaysFlush(boolean arg){alwaysFlush = arg;}
        public void wln(){out.println(); if(alwaysFlush)flush();}
        public void wln(int arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(long arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(double arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(String arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(boolean arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(char arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(float arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(Object arg){out.println(arg); if(alwaysFlush)flush();}
        public void w(int arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(long arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(double arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(String arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(boolean arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(char arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(float arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(Object arg){out.print(arg); if(alwaysFlush)flush();}
        public void wf(String format, Object...args){out.printf(format, args); if(alwaysFlush)flush();}
        public void flush(){out.flush();}
        public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
        public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
        public String nS() throws IOException {in.nextToken(); return in.sval;}
        public double nD() throws IOException {in.nextToken(); return in.nval;}
        public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
        public char nC() throws IOException {return (char)br.read();}
        public void wc(char...arg){for(char c : arg){in.ordinaryChar(c);in.wordChars(c, c);}}
        public void wc(String arg){wc(arg.toCharArray());}
        public void wc(char arg0, char arg1){in.ordinaryChars(arg0, arg1); in.wordChars(arg0, arg1);}
        public boolean eof(){return in.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol(){return in.ttype == StreamTokenizer.TT_EOL;}
    }
}

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Solution {
    private IO io;
    private int ioMode = -1;
    private String problemName = "";
    private final String mjArgument = "master_j";

    public static void main(String programArguments[]) throws IOException{
        if(programArguments != null && programArguments.length > 0)
            new Solution().run(programArguments[0]);
        else
            new Solution().run(null);
    }

    private void run(String programArgument) throws IOException {
        //         _______________________________________________ _________
        //        |   Input Mode     |      Output Mode    | mode | comment |
        //        |------------------|---------------------|----- |---------|
        //        |   input.txt      |      System.out     |  0   |    mj   |
        //        |   System.in      |      System.out     |  1   |  T / CF |
        //        |<problemName>.in  |  <problemName>.out  |  2   |         |
        //        |   input.txt      |      output.txt     |  3   |    C    |
        //        |__________________|_____________________|______|_________|
        long nanoTime = 0;
        if(programArgument != null && programArgument.equals(mjArgument)) // mj
            ioMode = 0;
        else if(System.getProperty("ONLINE_JUDGE") != null) // T / CF
            ioMode = 1;
        else
            ioMode = 2;
        switch(ioMode){
            case -1:
                try{
                    throw new Exception("<ioMode> init failure") ;
                }catch (Exception e){
                    e.printStackTrace();
                }
                return;
            case 0:
                break;
            case 1:
                break;
            case 2:
                if(problemName.length() == 0){
                    try{
                        throw new Exception("<problemName> init failure");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return;
                }
            case 3:
                break;
        }
        io = new IO(ioMode, problemName);
        if(ioMode == 0){
            System.out.println("File output : \n<start>");
            System.out.flush();
            nanoTime = System.nanoTime();
        }
        solve();
        io.flush();
        if(ioMode == 0){
            System.out.println("</start>");
            long t = System.nanoTime() - nanoTime;
            int d3 = 1000000000, d2 = 1000000, d1 = 1000;
            if(t>=d3)
                System.out.println(t/d3 + "." + t%d3 + " seconds");
            else if(t>=d2)
                System.out.println(t/d2 + "." + t%d2 + " millis");
            else if(t>=d1)
                System.out.println(t/d1 + "." + t%d1 + " micros");
            else
                System.out.println(t + " nanos");
            System.out.flush();
        }
    }

    private void solve() throws IOException {
        double r = io.nI(), h = io.nI();
        int ans = 0;
        ans += h/r*2;
        h %= r;
        double t = 0;
        if(h >= r/2.0)
            ans += 2;
        else{
            t -= r;
        }
        double r_2 = r/2.0;
        if(r*r <= dist_2(r_2, r_2, r_2-t, r_2, r, h-r_2))
            ans += 1;
        io.wln(ans);
    }//2.2250738585072012e-308

    double dist_2(double x1, double y1, double z1, double x2, double y2, double z2){
        double d = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) + (z1-z2)*(z1-z2);
        return d;
    }

    /**
     * Input-output class
     * @author master_j
     * @version 0.2.5
     */
    @SuppressWarnings("unused")
    private class IO{
        private boolean alwaysFlush;
        StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
        public IO(int ioMode, String problemName) throws IOException{
            Locale.setDefault(Locale.US);
            //         _______________________________________________ _________
            //        |   Input Mode     |      Output Mode    | mode | comment |
            //        |------------------|---------------------|----- |---------|
            //        |   input.txt      |      System.out     |  0   |    mj   |
            //        |   System.in      |      System.out     |  1   |  T / CF |
            //        |<problemName>.in  |  <problemName>.out  |  2   |         |
            //        |   input.txt      |      output.txt     |  3   |    C    |
            //        |__________________|_____________________|______|_________|
            switch(ioMode){
                case 0:
                    reader = new FileReader("input.txt");
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 1:
                    reader = new InputStreamReader(System.in);
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 2:
                    reader = new FileReader(problemName + ".in");
                    writer = new FileWriter(problemName + ".out");
                    break;
                case 3:
                    reader = new FileReader("input.txt");
                    writer = new FileWriter("output.txt");
                    break;
            }
            br = new BufferedReader(reader);
            in = new StreamTokenizer(br);
            out = new PrintWriter(writer);
            alwaysFlush = false;
        }
        public void setAlwaysFlush(boolean arg){alwaysFlush = arg;}
        public void wln(){out.println(); if(alwaysFlush)flush();}
        public void wln(int arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(long arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(double arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(String arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(boolean arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(char arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(float arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(Object arg){out.println(arg); if(alwaysFlush)flush();}
        public void w(int arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(long arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(double arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(String arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(boolean arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(char arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(float arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(Object arg){out.print(arg); if(alwaysFlush)flush();}
        public void wf(String format, Object...args){out.printf(format, args); if(alwaysFlush)flush();}
        public void flush(){out.flush();}
        public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
        public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
        public String nS() throws IOException {in.nextToken(); return in.sval;}
        public double nD() throws IOException {in.nextToken(); return in.nval;}
        public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
        public char nC() throws IOException {return (char)br.read();}
        public void wc(char...arg){for(char c : arg){in.ordinaryChar(c);in.wordChars(c, c);}}
        public void wc(String arg){wc(arg.toCharArray());}
        public void wc(char arg0, char arg1){in.ordinaryChars(arg0, arg1); in.wordChars(arg0, arg1);}
        public boolean eof(){return in.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol(){return in.ttype == StreamTokenizer.TT_EOL;}
    }
}

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Solution {
    private IO io;
    private int ioMode = -1;
    private String problemName = "";
    private final String mjArgument = "master_j";

    public static void main(String programArguments[]) throws IOException{
        if(programArguments != null && programArguments.length > 0)
            new Solution().run(programArguments[0]);
        else
            new Solution().run(null);
    }

    private void run(String programArgument) throws IOException {
        //         _______________________________________________ _________
        //        |   Input Mode     |      Output Mode    | mode | comment |
        //        |------------------|---------------------|----- |---------|
        //        |   input.txt      |      System.out     |  0   |    mj   |
        //        |   System.in      |      System.out     |  1   |  T / CF |
        //        |<problemName>.in  |  <problemName>.out  |  2   |         |
        //        |   input.txt      |      output.txt     |  3   |    C    |
        //        |__________________|_____________________|______|_________|
        long nanoTime = 0;
        if(programArgument != null && programArgument.equals(mjArgument)) // mj
            ioMode = 0;
        else if(System.getProperty("ONLINE_JUDGE") != null) // T / CF
            ioMode = 1;
        else
            ioMode = 2;
        switch(ioMode){
            case -1:
                try{
                    throw new Exception("<ioMode> init failure") ;
                }catch (Exception e){
                    e.printStackTrace();
                }
                return;
            case 0:
                break;
            case 1:
                break;
            case 2:
                if(problemName.length() == 0){
                    try{
                        throw new Exception("<problemName> init failure");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return;
                }
            case 3:
                break;
        }
        io = new IO(ioMode, problemName);
        if(ioMode == 0){
            System.out.println("File output : \n<start>");
            System.out.flush();
            nanoTime = System.nanoTime();
        }
        solve();
        io.flush();
        if(ioMode == 0){
            System.out.println("</start>");
            long t = System.nanoTime() - nanoTime;
            int d3 = 1000000000, d2 = 1000000, d1 = 1000;
            if(t>=d3)
                System.out.println(t/d3 + "." + t%d3 + " seconds");
            else if(t>=d2)
                System.out.println(t/d2 + "." + t%d2 + " millis");
            else if(t>=d1)
                System.out.println(t/d1 + "." + t%d1 + " micros");
            else
                System.out.println(t + " nanos");
            System.out.flush();
        }
    }

    private void solve() throws IOException {
        int r = io.nI(), h = io.nI(), ans = 0;
        ans += h/r*2;
        h %= r;
        double t = 0;
        if(h >= r/2.0)
            ans += 2;
        else{
            t -= r;
        }
        double r_2 = r/2.0;
        if(r <= dist(r_2, r_2, r_2 - t, r_2, r, h - r_2))
            ans += 1;
        io.wln(ans);
    }//2.2250738585072012e-308

    double dist(double x1, double y1, double z1, double x2, double y2, double z2){
        double d = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) + (z1-z2)*(z1-z2);
        return sqrt(d);
    }

    /**
     * Input-output class
     * @author master_j
     * @version 0.2.5
     */
    @SuppressWarnings("unused")
    private class IO{
        private boolean alwaysFlush;
        StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
        public IO(int ioMode, String problemName) throws IOException{
            Locale.setDefault(Locale.US);
            //         _______________________________________________ _________
            //        |   Input Mode     |      Output Mode    | mode | comment |
            //        |------------------|---------------------|----- |---------|
            //        |   input.txt      |      System.out     |  0   |    mj   |
            //        |   System.in      |      System.out     |  1   |  T / CF |
            //        |<problemName>.in  |  <problemName>.out  |  2   |         |
            //        |   input.txt      |      output.txt     |  3   |    C    |
            //        |__________________|_____________________|______|_________|
            switch(ioMode){
                case 0:
                    reader = new FileReader("input.txt");
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 1:
                    reader = new InputStreamReader(System.in);
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 2:
                    reader = new FileReader(problemName + ".in");
                    writer = new FileWriter(problemName + ".out");
                    break;
                case 3:
                    reader = new FileReader("input.txt");
                    writer = new FileWriter("output.txt");
                    break;
            }
            br = new BufferedReader(reader);
            in = new StreamTokenizer(br);
            out = new PrintWriter(writer);
            alwaysFlush = false;
        }
        public void setAlwaysFlush(boolean arg){alwaysFlush = arg;}
        public void wln(){out.println(); if(alwaysFlush)flush();}
        public void wln(int arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(long arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(double arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(String arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(boolean arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(char arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(float arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(Object arg){out.println(arg); if(alwaysFlush)flush();}
        public void w(int arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(long arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(double arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(String arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(boolean arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(char arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(float arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(Object arg){out.print(arg); if(alwaysFlush)flush();}
        public void wf(String format, Object...args){out.printf(format, args); if(alwaysFlush)flush();}
        public void flush(){out.flush();}
        public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
        public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
        public String nS() throws IOException {in.nextToken(); return in.sval;}
        public double nD() throws IOException {in.nextToken(); return in.nval;}
        public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
        public char nC() throws IOException {return (char)br.read();}
        public void wc(char...arg){for(char c : arg){in.ordinaryChar(c);in.wordChars(c, c);}}
        public void wc(String arg){wc(arg.toCharArray());}
        public void wc(char arg0, char arg1){in.ordinaryChars(arg0, arg1); in.wordChars(arg0, arg1);}
        public boolean eof(){return in.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol(){return in.ttype == StreamTokenizer.TT_EOL;}
    }
}

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Solution {
    private IO io;
    private int ioMode = -1;
    private String problemName = "";
    private final String mjArgument = "master_j";

    public static void main(String programArguments[]) throws IOException{
        if(programArguments != null && programArguments.length > 0)
            new Solution().run(programArguments[0]);
        else
            new Solution().run(null);
    }

    private void run(String programArgument) throws IOException {
        //         _______________________________________________ _________
        //        |   Input Mode     |      Output Mode    | mode | comment |
        //        |------------------|---------------------|----- |---------|
        //        |   input.txt      |      System.out     |  0   |    mj   |
        //        |   System.in      |      System.out     |  1   |  T / CF |
        //        |<problemName>.in  |  <problemName>.out  |  2   |         |
        //        |   input.txt      |      output.txt     |  3   |    C    |
        //        |__________________|_____________________|______|_________|
        long nanoTime = 0;
        if(programArgument != null && programArgument.equals(mjArgument)) // mj
            ioMode = 0;
        else if(System.getProperty("ONLINE_JUDGE") != null) // T / CF
            ioMode = 1;
        else
            ioMode = 2;
        switch(ioMode){
            case -1:
                try{
                    throw new Exception("<ioMode> init failure") ;
                }catch (Exception e){
                    e.printStackTrace();
                }
                return;
            case 0:
                break;
            case 1:
                break;
            case 2:
                if(problemName.length() == 0){
                    try{
                        throw new Exception("<problemName> init failure");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return;
                }
            case 3:
                break;
        }
        io = new IO(ioMode, problemName);
        if(ioMode == 0){
            System.out.println("File output : \n<start>");
            System.out.flush();
            nanoTime = System.nanoTime();
        }
        solve();
        io.flush();
        if(ioMode == 0){
            System.out.println("</start>");
            long t = System.nanoTime() - nanoTime;
            int d3 = 1000000000, d2 = 1000000, d1 = 1000;
            if(t>=d3)
                System.out.println(t/d3 + "." + t%d3 + " seconds");
            else if(t>=d2)
                System.out.println(t/d2 + "." + t%d2 + " millis");
            else if(t>=d1)
                System.out.println(t/d1 + "." + t%d1 + " micros");
            else
                System.out.println(t + " nanos");
            System.out.flush();
        }
    }

    private void solve() throws IOException {
        int r = io.nI(), h = io.nI(), ans = 0;
        ans += h/r*2;
        h %= r;
        double t = 0;
        if(h >= r/2.0)
            ans += 2;
        else{
            t -= r;
        }
        double r_2 = r/2.0;
        if(r*r <= dist_2(r_2, r_2, r_2-t, r_2, r, h-r_2))
            ans += 1;
        io.wln(ans);
    }//2.2250738585072012e-308

    double dist_2(double x1, double y1, double z1, double x2, double y2, double z2){
        double d = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) + (z1-z2)*(z1-z2);
        return d;
    }

    /**
     * Input-output class
     * @author master_j
     * @version 0.2.5
     */
    @SuppressWarnings("unused")
    private class IO{
        private boolean alwaysFlush;
        StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
        public IO(int ioMode, String problemName) throws IOException{
            Locale.setDefault(Locale.US);
            //         _______________________________________________ _________
            //        |   Input Mode     |      Output Mode    | mode | comment |
            //        |------------------|---------------------|----- |---------|
            //        |   input.txt      |      System.out     |  0   |    mj   |
            //        |   System.in      |      System.out     |  1   |  T / CF |
            //        |<problemName>.in  |  <problemName>.out  |  2   |         |
            //        |   input.txt      |      output.txt     |  3   |    C    |
            //        |__________________|_____________________|______|_________|
            switch(ioMode){
                case 0:
                    reader = new FileReader("input.txt");
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 1:
                    reader = new InputStreamReader(System.in);
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 2:
                    reader = new FileReader(problemName + ".in");
                    writer = new FileWriter(problemName + ".out");
                    break;
                case 3:
                    reader = new FileReader("input.txt");
                    writer = new FileWriter("output.txt");
                    break;
            }
            br = new BufferedReader(reader);
            in = new StreamTokenizer(br);
            out = new PrintWriter(writer);
            alwaysFlush = false;
        }
        public void setAlwaysFlush(boolean arg){alwaysFlush = arg;}
        public void wln(){out.println(); if(alwaysFlush)flush();}
        public void wln(int arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(long arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(double arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(String arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(boolean arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(char arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(float arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(Object arg){out.println(arg); if(alwaysFlush)flush();}
        public void w(int arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(long arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(double arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(String arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(boolean arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(char arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(float arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(Object arg){out.print(arg); if(alwaysFlush)flush();}
        public void wf(String format, Object...args){out.printf(format, args); if(alwaysFlush)flush();}
        public void flush(){out.flush();}
        public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
        public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
        public String nS() throws IOException {in.nextToken(); return in.sval;}
        public double nD() throws IOException {in.nextToken(); return in.nval;}
        public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
        public char nC() throws IOException {return (char)br.read();}
        public void wc(char...arg){for(char c : arg){in.ordinaryChar(c);in.wordChars(c, c);}}
        public void wc(String arg){wc(arg.toCharArray());}
        public void wc(char arg0, char arg1){in.ordinaryChars(arg0, arg1); in.wordChars(arg0, arg1);}
        public boolean eof(){return in.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol(){return in.ttype == StreamTokenizer.TT_EOL;}
    }
}

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Solution {
    private IO io;
    private int ioMode = -1;
    private String problemName = "";
    private final String mjArgument = "master_j";

    public static void main(String programArguments[]) throws IOException{
        if(programArguments != null && programArguments.length > 0)
            new Solution().run(programArguments[0]);
        else
            new Solution().run(null);
    }

    private void run(String programArgument) throws IOException {
        //         _______________________________________________ _________
        //        |   Input Mode     |      Output Mode    | mode | comment |
        //        |------------------|---------------------|----- |---------|
        //        |   input.txt      |      System.out     |  0   |    mj   |
        //        |   System.in      |      System.out     |  1   |  T / CF |
        //        |<problemName>.in  |  <problemName>.out  |  2   |         |
        //        |   input.txt      |      output.txt     |  3   |    C    |
        //        |__________________|_____________________|______|_________|
        long nanoTime = 0;
        if(programArgument != null && programArgument.equals(mjArgument)) // mj
            ioMode = 0;
        else if(System.getProperty("ONLINE_JUDGE") != null) // T / CF
            ioMode = 1;
        else
            ioMode = 2;
        switch(ioMode){
            case -1:
                try{
                    throw new Exception("<ioMode> init failure") ;
                }catch (Exception e){
                    e.printStackTrace();
                }
                return;
            case 0:
                break;
            case 1:
                break;
            case 2:
                if(problemName.length() == 0){
                    try{
                        throw new Exception("<problemName> init failure");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return;
                }
            case 3:
                break;
        }
        io = new IO(ioMode, problemName);
        if(ioMode == 0){
            System.out.println("File output : \n<start>");
            System.out.flush();
            nanoTime = System.nanoTime();
        }
        solve();
        io.flush();
        if(ioMode == 0){
            System.out.println("</start>");
            long t = System.nanoTime() - nanoTime;
            int d3 = 1000000000, d2 = 1000000, d1 = 1000;
            if(t>=d3)
                System.out.println(t/d3 + "." + t%d3 + " seconds");
            else if(t>=d2)
                System.out.println(t/d2 + "." + t%d2 + " millis");
            else if(t>=d1)
                System.out.println(t/d1 + "." + t%d1 + " micros");
            else
                System.out.println(t + " nanos");
            System.out.flush();
        }
    }

    private void solve() throws IOException {
        double r = io.nI(), h = io.nI();
        long ans = (long)(h / r);
        h -= r*(long)(h/r);
        if(h >= r/2)
            ans++;
        else
            h -= r;
        ans *= 2;
        if(r <= dist(r/2, r/2, r/2, r/2, r, h-r/2))
            ans += 1;
        io.wln(ans);
    }//2.2250738585072012e-308

    double dist(double x1, double y1, double z1, double x2, double y2, double z2){
        //double d = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) + (z1-z2)*(z1-z2);
        double d1 = (y1-y2)*(y1-y2);
        double d2 = (z1-z2)*(z1-z2);
        double d = d1 + d2;
        return sqrt(d);
    }

    /**
     * Input-output class
     * @author master_j
     * @version 0.2.5
     */
    @SuppressWarnings("unused")
    private class IO{
        private boolean alwaysFlush;
        StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
        public IO(int ioMode, String problemName) throws IOException{
            Locale.setDefault(Locale.US);
            //         _______________________________________________ _________
            //        |   Input Mode     |      Output Mode    | mode | comment |
            //        |------------------|---------------------|----- |---------|
            //        |   input.txt      |      System.out     |  0   |    mj   |
            //        |   System.in      |      System.out     |  1   |  T / CF |
            //        |<problemName>.in  |  <problemName>.out  |  2   |         |
            //        |   input.txt      |      output.txt     |  3   |    C    |
            //        |__________________|_____________________|______|_________|
            switch(ioMode){
                case 0:
                    reader = new FileReader("input.txt");
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 1:
                    reader = new InputStreamReader(System.in);
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 2:
                    reader = new FileReader(problemName + ".in");
                    writer = new FileWriter(problemName + ".out");
                    break;
                case 3:
                    reader = new FileReader("input.txt");
                    writer = new FileWriter("output.txt");
                    break;
            }
            br = new BufferedReader(reader);
            in = new StreamTokenizer(br);
            out = new PrintWriter(writer);
            alwaysFlush = false;
        }
        public void setAlwaysFlush(boolean arg){alwaysFlush = arg;}
        public void wln(){out.println(); if(alwaysFlush)flush();}
        public void wln(int arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(long arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(double arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(String arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(boolean arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(char arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(float arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(Object arg){out.println(arg); if(alwaysFlush)flush();}
        public void w(int arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(long arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(double arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(String arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(boolean arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(char arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(float arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(Object arg){out.print(arg); if(alwaysFlush)flush();}
        public void wf(String format, Object...args){out.printf(format, args); if(alwaysFlush)flush();}
        public void flush(){out.flush();}
        public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
        public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
        public String nS() throws IOException {in.nextToken(); return in.sval;}
        public double nD() throws IOException {in.nextToken(); return in.nval;}
        public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
        public char nC() throws IOException {return (char)br.read();}
        public void wc(char...arg){for(char c : arg){in.ordinaryChar(c);in.wordChars(c, c);}}
        public void wc(String arg){wc(arg.toCharArray());}
        public void wc(char arg0, char arg1){in.ordinaryChars(arg0, arg1); in.wordChars(arg0, arg1);}
        public boolean eof(){return in.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol(){return in.ttype == StreamTokenizer.TT_EOL;}
    }
}

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Solution {
    private IO io;
    private int ioMode = -1;
    private String problemName = "";
    private final String mjArgument = "master_j";

    public static void main(String programArguments[]) throws IOException{
        if(programArguments != null && programArguments.length > 0)
            new Solution().run(programArguments[0]);
        else
            new Solution().run(null);
    }

    private void run(String programArgument) throws IOException {
        //         _______________________________________________ _________
        //        |   Input Mode     |      Output Mode    | mode | comment |
        //        |------------------|---------------------|----- |---------|
        //        |   input.txt      |      System.out     |  0   |    mj   |
        //        |   System.in      |      System.out     |  1   |  T / CF |
        //        |<problemName>.in  |  <problemName>.out  |  2   |         |
        //        |   input.txt      |      output.txt     |  3   |    C    |
        //        |__________________|_____________________|______|_________|
        long nanoTime = 0;
        if(programArgument != null && programArgument.equals(mjArgument)) // mj
            ioMode = 0;
        else if(System.getProperty("ONLINE_JUDGE") != null) // T / CF
            ioMode = 1;
        else
            ioMode = 2;
        switch(ioMode){
            case -1:
                try{
                    throw new Exception("<ioMode> init failure") ;
                }catch (Exception e){
                    e.printStackTrace();
                }
                return;
            case 0:
                break;
            case 1:
                break;
            case 2:
                if(problemName.length() == 0){
                    try{
                        throw new Exception("<problemName> init failure");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return;
                }
            case 3:
                break;
        }
        io = new IO(ioMode, problemName);
        if(ioMode == 0){
            System.out.println("File output : \n<start>");
            System.out.flush();
            nanoTime = System.nanoTime();
        }
        solve();
        io.flush();
        if(ioMode == 0){
            System.out.println("</start>");
            long t = System.nanoTime() - nanoTime;
            int d3 = 1000000000, d2 = 1000000, d1 = 1000;
            if(t>=d3)
                System.out.println(t/d3 + "." + t%d3 + " seconds");
            else if(t>=d2)
                System.out.println(t/d2 + "." + t%d2 + " millis");
            else if(t>=d1)
                System.out.println(t/d1 + "." + t%d1 + " micros");
            else
                System.out.println(t + " nanos");
            System.out.flush();
        }
    }

    private void solve() throws IOException {
        double r = io.nI(), h = io.nI();
        long ans = 2 * (long)((h + 0.5*r) / r);
        h -= r*(long)(h/r);
        if(r <= dist(r/2, r/2, r/2, r/2, r, h-r/2))
            ans += 1;
        io.wln(ans);
    }//2.2250738585072012e-308

    double dist(double x1, double y1, double z1, double x2, double y2, double z2){
        //double d = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) + (z1-z2)*(z1-z2);
        double d1 = (y1-y2)*(y1-y2);
        double d2 = (z1-z2)*(z1-z2);
        double d = d1 + d2;
        return sqrt(d);
    }

    /**
     * Input-output class
     * @author master_j
     * @version 0.2.5
     */
    @SuppressWarnings("unused")
    private class IO{
        private boolean alwaysFlush;
        StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
        public IO(int ioMode, String problemName) throws IOException{
            Locale.setDefault(Locale.US);
            //         _______________________________________________ _________
            //        |   Input Mode     |      Output Mode    | mode | comment |
            //        |------------------|---------------------|----- |---------|
            //        |   input.txt      |      System.out     |  0   |    mj   |
            //        |   System.in      |      System.out     |  1   |  T / CF |
            //        |<problemName>.in  |  <problemName>.out  |  2   |         |
            //        |   input.txt      |      output.txt     |  3   |    C    |
            //        |__________________|_____________________|______|_________|
            switch(ioMode){
                case 0:
                    reader = new FileReader("input.txt");
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 1:
                    reader = new InputStreamReader(System.in);
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 2:
                    reader = new FileReader(problemName + ".in");
                    writer = new FileWriter(problemName + ".out");
                    break;
                case 3:
                    reader = new FileReader("input.txt");
                    writer = new FileWriter("output.txt");
                    break;
            }
            br = new BufferedReader(reader);
            in = new StreamTokenizer(br);
            out = new PrintWriter(writer);
            alwaysFlush = false;
        }
        public void setAlwaysFlush(boolean arg){alwaysFlush = arg;}
        public void wln(){out.println(); if(alwaysFlush)flush();}
        public void wln(int arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(long arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(double arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(String arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(boolean arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(char arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(float arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(Object arg){out.println(arg); if(alwaysFlush)flush();}
        public void w(int arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(long arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(double arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(String arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(boolean arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(char arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(float arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(Object arg){out.print(arg); if(alwaysFlush)flush();}
        public void wf(String format, Object...args){out.printf(format, args); if(alwaysFlush)flush();}
        public void flush(){out.flush();}
        public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
        public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
        public String nS() throws IOException {in.nextToken(); return in.sval;}
        public double nD() throws IOException {in.nextToken(); return in.nval;}
        public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
        public char nC() throws IOException {return (char)br.read();}
        public void wc(char...arg){for(char c : arg){in.ordinaryChar(c);in.wordChars(c, c);}}
        public void wc(String arg){wc(arg.toCharArray());}
        public void wc(char arg0, char arg1){in.ordinaryChars(arg0, arg1); in.wordChars(arg0, arg1);}
        public boolean eof(){return in.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol(){return in.ttype == StreamTokenizer.TT_EOL;}
    }
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {

    void solve() throws Exception{
        int r = in.nextInt();
        int  h = in.nextInt();
        if (r > h){
            out.println(2);
            return;
        }
        int ans = (h / r) * 2 + (h % r > 0 ? 2 : 1);
        out.println(ans);
    }

    String input = "";
    String output = "";
    FastScanner in;
    PrintWriter out;

    void run() throws Exception {
        if (input.length() == 0) {
            in = new FastScanner(System.in);
        } else {
            in = new FastScanner(new File(input));
        }
        if (output.length() == 0) {
            out = new PrintWriter(System.out);
        } else {
            out = new PrintWriter(new File(output));
        }

        solve();

        out.close();

    }

    public static void main(String[] args) throws Exception {
        new C().run();
    }

    class FastScanner {

        BufferedReader bf;
        StringTokenizer st;

        public FastScanner(InputStream is) {
            bf = new BufferedReader(new InputStreamReader(is));
        }

        public FastScanner(File fr) throws FileNotFoundException {
            bf = new BufferedReader(new FileReader(fr));
        }

        public String next() {
            try {
                while (st == null || !st.hasMoreTokens()) {
                    st = new StringTokenizer(bf.readLine());
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}

//package Round_199;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {

    void solve() throws Exception{
        int r = in.nextInt();
        int  h = in.nextInt();
        if (r > h){
            if (r / h == 1)
                out.println(2);
            else
                out.println(1);
            return;
        }
        int ans = (h / r) * 2 + (h % r > 0 ? 2 : 1);
        out.println(ans);
    }

    String input = "";
    String output = "";
    FastScanner in;
    PrintWriter out;

    void run() throws Exception {
        if (input.length() == 0) {
            in = new FastScanner(System.in);
        } else {
            in = new FastScanner(new File(input));
        }
        if (output.length() == 0) {
            out = new PrintWriter(System.out);
        } else {
            out = new PrintWriter(new File(output));
        }

        solve();

        out.close();

    }

    public static void main(String[] args) throws Exception {
        new C().run();
    }

    class FastScanner {

        BufferedReader bf;
        StringTokenizer st;

        public FastScanner(InputStream is) {
            bf = new BufferedReader(new InputStreamReader(is));
        }

        public FastScanner(File fr) throws FileNotFoundException {
            bf = new BufferedReader(new FileReader(fr));
        }

        public String next() {
            try {
                while (st == null || !st.hasMoreTokens()) {
                    st = new StringTokenizer(bf.readLine());
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}

//package Round_199;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {

    void solve() throws Exception{
        int r = in.nextInt();
        int  h = in.nextInt();
        if (r > h){
            if (2 * h >= r)
                out.println(2);
            else
                out.println(1);
            return;
        }
        int ans = (h / r) * 2 + (h % r > 0 ? 2 : 1);
        out.println(ans);
    }

    String input = "";
    String output = "";
    FastScanner in;
    PrintWriter out;

    void run() throws Exception {
        if (input.length() == 0) {
            in = new FastScanner(System.in);
        } else {
            in = new FastScanner(new File(input));
        }
        if (output.length() == 0) {
            out = new PrintWriter(System.out);
        } else {
            out = new PrintWriter(new File(output));
        }

        solve();

        out.close();

    }

    public static void main(String[] args) throws Exception {
        new C().run();
    }

    class FastScanner {

        BufferedReader bf;
        StringTokenizer st;

        public FastScanner(InputStream is) {
            bf = new BufferedReader(new InputStreamReader(is));
        }

        public FastScanner(File fr) throws FileNotFoundException {
            bf = new BufferedReader(new FileReader(fr));
        }

        public String next() {
            try {
                while (st == null || !st.hasMoreTokens()) {
                    st = new StringTokenizer(bf.readLine());
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}

//package Round_199;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {

    void solve() throws Exception{
        int r = in.nextInt();
        int  h = in.nextInt();
        if (r > h){
            if (r / h > 1)
                out.println(2);
            else
                out.println(1);
            return;
        }
        int ans = (h / r) * 2 + (h % r > 0 ? 2 : 1);
        out.println(ans);
    }

    String input = "";
    String output = "";
    FastScanner in;
    PrintWriter out;

    void run() throws Exception {
        if (input.length() == 0) {
            in = new FastScanner(System.in);
        } else {
            in = new FastScanner(new File(input));
        }
        if (output.length() == 0) {
            out = new PrintWriter(System.out);
        } else {
            out = new PrintWriter(new File(output));
        }

        solve();

        out.close();

    }

    public static void main(String[] args) throws Exception {
        new C().run();
    }

    class FastScanner {

        BufferedReader bf;
        StringTokenizer st;

        public FastScanner(InputStream is) {
            bf = new BufferedReader(new InputStreamReader(is));
        }

        public FastScanner(File fr) throws FileNotFoundException {
            bf = new BufferedReader(new FileReader(fr));
        }

        public String next() {
            try {
                while (st == null || !st.hasMoreTokens()) {
                    st = new StringTokenizer(bf.readLine());
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {

    void solve() throws Exception{
        int r = in.nextInt();
        int  h = in.nextInt();
        if (r > h){
            if (2 * h >= r)
                out.println(2);
            else
                out.println(1);
            return;
        }
        int ans = (h / r) * 2;
        h = h % r;
        if (2 * h >= r)
            ans += 2;
        else
            ans++;
        out.println(ans);
    }

    String input = "";
    String output = "";
    FastScanner in;
    PrintWriter out;

    void run() throws Exception {
        if (input.length() == 0) {
            in = new FastScanner(System.in);
        } else {
            in = new FastScanner(new File(input));
        }
        if (output.length() == 0) {
            out = new PrintWriter(System.out);
        } else {
            out = new PrintWriter(new File(output));
        }

        solve();

        out.close();

    }

    public static void main(String[] args) throws Exception {
        new C().run();
    }

    class FastScanner {

        BufferedReader bf;
        StringTokenizer st;

        public FastScanner(InputStream is) {
            bf = new BufferedReader(new InputStreamReader(is));
        }

        public FastScanner(File fr) throws FileNotFoundException {
            bf = new BufferedReader(new FileReader(fr));
        }

        public String next() {
            try {
                while (st == null || !st.hasMoreTokens()) {
                    st = new StringTokenizer(bf.readLine());
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}

import static java.util.Arrays.deepToString;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class Main {

    static void solve() throws IOException {
        int r = nextInt();
        int h = nextInt();
        int count = 0;

        count = (int) Math.ceil(1.0 * h / r) * 2;
        double l = r * Math.ceil(1.0 * h / r) - r / 2.0;
        if (Math.sqrt(3) * r / 2 + l <= r / 2.0 + h) {
            count++;
        }
        writer.println(count);
    }

    public static void main(String[] args) throws Exception {
        reader = new BufferedReader(new InputStreamReader(System.in));
        writer = new PrintWriter(System.out);
        // reader = new BufferedReader(new FileReader("input.txt"));
        // writer = new PrintWriter("output.txt");
        setTime();
        solve();
        printTime();
        printMemory();

        writer.close();
    }

    static BufferedReader reader;
    static PrintWriter writer;
    static StringTokenizer tok = new StringTokenizer("");
    static long systemTime;

    static void debug(Object... o) {
        System.err.println(deepToString(o));
    }

    static void setTime() {
        systemTime = System.currentTimeMillis();
    }

    static void printTime() {
        System.err.println("Time consumed: "
                + (System.currentTimeMillis() - systemTime));
    }

    static void printMemory() {
        System.err.println("Memory consumed: "
                + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime()
                        .freeMemory()) / 1000 + "kb");
    }

    static String next() {
        while (!tok.hasMoreTokens()) {
            String w = null;
            try {
                w = reader.readLine();
            } catch (Exception e) {
                e.printStackTrace();
            }
            if (w == null)
                return null;
            tok = new StringTokenizer(w);
        }
        return tok.nextToken();
    }

    static int nextInt() {
        return Integer.parseInt(next());
    }

    static long nextLong() {
        return Long.parseLong(next());
    }

    static double nextDouble() {
        return Double.parseDouble(next());
    }

    static BigInteger nextBigInteger() {
        return new BigInteger(next());
    }
}

import static java.util.Arrays.deepToString;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class Main {

    static void solve() throws IOException {
        int r = nextInt();
        int h = nextInt();
        int count = 0;
        if (h >= r / 2.0) {
            count = (int) Math.ceil(h / r) * 2;
            double l = h - (r * Math.floor(h / r) + r / 2.0);
            if (l + Math.sqrt(3) / 2 <= r) {
                count++;
            }
        } else {
            writer.println(2);
        }

        writer.println(count);
    }

    public static void main(String[] args) throws Exception {
        reader = new BufferedReader(new InputStreamReader(System.in));
        writer = new PrintWriter(System.out);
        // reader = new BufferedReader(new FileReader("input.txt"));
        // writer = new PrintWriter("output.txt");
        setTime();
        solve();
        printTime();
        printMemory();

        writer.close();
    }

    static BufferedReader reader;
    static PrintWriter writer;
    static StringTokenizer tok = new StringTokenizer("");
    static long systemTime;

    static void debug(Object... o) {
        System.err.println(deepToString(o));
    }

    static void setTime() {
        systemTime = System.currentTimeMillis();
    }

    static void printTime() {
        System.err.println("Time consumed: "
                + (System.currentTimeMillis() - systemTime));
    }

    static void printMemory() {
        System.err.println("Memory consumed: "
                + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime()
                        .freeMemory()) / 1000 + "kb");
    }

    static String next() {
        while (!tok.hasMoreTokens()) {
            String w = null;
            try {
                w = reader.readLine();
            } catch (Exception e) {
                e.printStackTrace();
            }
            if (w == null)
                return null;
            tok = new StringTokenizer(w);
        }
        return tok.nextToken();
    }

    static int nextInt() {
        return Integer.parseInt(next());
    }

    static long nextLong() {
        return Long.parseLong(next());
    }

    static double nextDouble() {
        return Double.parseDouble(next());
    }

    static BigInteger nextBigInteger() {
        return new BigInteger(next());
    }
}

import static java.util.Arrays.deepToString;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class Main {

    static void solve() throws IOException {
        int r = nextInt();
        int h = nextInt();
        int count = 0;
        if (h >= r / 2.0) {

            count = (int) Math.ceil(1.0 * h / r) * 2;
            double l = r * Math.ceil(1.0 * h / r) - r / 2.0;
            if (Math.sqrt(3) * r / 2 + l <= r / 2.0 + h) {
                count++;
            }
        } else {
            count = 1;
        }
        writer.println(count);
    }

    public static void main(String[] args) throws Exception {
        reader = new BufferedReader(new InputStreamReader(System.in));
        writer = new PrintWriter(System.out);
        // reader = new BufferedReader(new FileReader("input.txt"));
        // writer = new PrintWriter("output.txt");
        setTime();
        solve();
        printTime();
        printMemory();

        writer.close();
    }

    static BufferedReader reader;
    static PrintWriter writer;
    static StringTokenizer tok = new StringTokenizer("");
    static long systemTime;

    static void debug(Object... o) {
        System.err.println(deepToString(o));
    }

    static void setTime() {
        systemTime = System.currentTimeMillis();
    }

    static void printTime() {
        System.err.println("Time consumed: "
                + (System.currentTimeMillis() - systemTime));
    }

    static void printMemory() {
        System.err.println("Memory consumed: "
                + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime()
                        .freeMemory()) / 1000 + "kb");
    }

    static String next() {
        while (!tok.hasMoreTokens()) {
            String w = null;
            try {
                w = reader.readLine();
            } catch (Exception e) {
                e.printStackTrace();
            }
            if (w == null)
                return null;
            tok = new StringTokenizer(w);
        }
        return tok.nextToken();
    }

    static int nextInt() {
        return Integer.parseInt(next());
    }

    static long nextLong() {
        return Long.parseLong(next());
    }

    static double nextDouble() {
        return Double.parseDouble(next());
    }

    static BigInteger nextBigInteger() {
        return new BigInteger(next());
    }
}

import java.util.Scanner;

public class C_199_D2_C {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int r = sc.nextInt();
		int h = sc.nextInt();
		int count = 0;
		count = (int)(h/r) * 2;
		h -= (int)(h / r) * r;
		double x = (Math.sqrt(3) / 2) * r + r / 2.0;
		if (4 * h * h >= 3 * r * r){
			count += 3;
		} else {
			if (h >= r / 2.0){
				count += 2;
			} else {
				count += 1;
			}
		}
		System.out.println(count);
	}

}

import java.util.Scanner;

public class C_199_D2_C {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		long r = sc.nextLong();
		long h = sc.nextLong();
		int count = 0;
		count = (int) (h / r);
		h -= count * r;
		count *= 2;
		if (41 * h * h >= 31 * r * r) {
			count += 3;
		} else {
			if (h * 2 >= r ){
				count += 2;
			} else {
				count += 1;
			}
		}
		System.out.println(count);
		sc.close();
	}

}

import java.util.Scanner;

public class C_199_D2_C {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int r = sc.nextInt();
        int h = sc.nextInt();
        int count = 0;
        count = (int)(h/r) * 2;
        h -= (int)(h/r);
        double x = (Math.sqrt(3) / 4) * r + r / 2.0;
        if (h >= x){
            count += 2;
        } else {
            if (h >= r / 2.0){
                count += 2;
            } else {
                count += 1;
            }
        }
        System.out.println(count);
    }

}

import java.util.Scanner;

public class C_199_D2_C {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int r = sc.nextInt();
        int h = sc.nextInt();
        int count = 0;
        count = (int)(h/r) * 2;
        h -= (int)(h / r) * r;
        double x = (Math.sqrt(3) / 2) * r + r / 2.0;
        if (h >= x){
            count += 3;
        } else {
            if (h >= r / 2.0){
                count += 2;
            } else {
                count += 1;
            }
        }
        System.out.println(count);
    }

}

import java.util.Scanner;
import java.io.PrintStream;
import java.io.BufferedReader;
import java.io.StreamTokenizer;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author KNIGHT0X300
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputStreamReader in = new InputStreamReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    StreamTokenizer in;
    PrintWriter out;
    BufferedReader re;
    Scanner sc;
    public void solve (int testNumber, InputStreamReader in, PrintWriter out)  {

          this.in = new StreamTokenizer(new BufferedReader(in));
          this.re =  new BufferedReader(in);
          this.sc = new Scanner(in);
          this.out = out;
          try {
                      this.solve();
                  } catch (IOException e) {
                      e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
                  }
          out.flush();

    }

         /////////////////////////////////////////////////////////////
     int nextInt() throws IOException
       {
          in.nextToken();
          return (int)in.nval;
       }

     void solve() throws IOException
       {
           int r=nextInt(),h=nextInt();
           int ans=h/r;
           ans*=2;
           h%=r;
         if((double)h>=(double)r/2.0) ans+=2;
           else
             ans+=1;
           out.println(ans);
         // do the sum
       }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {

    static StringTokenizer st;
    static BufferedReader br;
    static PrintWriter pw;
    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int r = nextInt();
        int h = nextInt();
        int cnt = h / r;
        int ans = cnt*2;
        h -= cnt*r;
        if (2*h >= r) {
            ans += 2;
            if (3l*r*r <= (long)(2*h+r)*(2*h+r))
                ans++;
        }
        else
            ans++;
        System.out.println(ans);
    }
    private static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }
    private static long nextLong() throws IOException {
        return Long.parseLong(next());
    }
    private static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
    private static String next() throws IOException {
        while (st==null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {

    static StringTokenizer st;
    static BufferedReader br;
    static PrintWriter pw;
    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int r = nextInt();
        int h = nextInt();
        int cnt = h / r;
        int ans = cnt*2;
        h -= cnt*r;
        if (2*h >= r)
            ans += 2;
        else
            ans++;
        System.out.println(ans);
    }
    private static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }
    private static long nextLong() throws IOException {
        return Long.parseLong(next());
    }
    private static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
    private static String next() throws IOException {
        while (st==null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }
}

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;
import java.io.Writer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Dylan
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskC {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
        int r = in.nextInt();
        int h = in.nextInt();
        int ans = (h / r) * 2;
        double hh = 1.0 * h - ans / 2 * r;
        if(2 * hh >= r) {
            ans += 2;
        } else {
            if(2 * (hh + r) + r > (1.0 + Math.sqrt(3)) * r)
                ans++;
        }
        out.println(ans);
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}

class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void println(Object... objects) {
        print(objects);
        writer.println();
    }

    public void close() {
        writer.close();
    }

    }

import java.util.*;
import java.io.*;

public class C {
/*

 */
    public static BR in;
    public static LR lin;
    public static PrintWriter out;
    public static PrintWriter fout;
    static {
        try {
            in = new BR();
            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out  ) ) );
            fout = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream("output.txt") ) ) );
        }
        catch (Exception e){

        }
    }

    public static boolean bg = true;
    public static void main(String[] args) throws Exception {
        s1();
        out.close();
    }
    private static void s1() throws Exception {
        int r = in.ni();
        int h = in.ni();
        int H = h * 2;
        int max = Integer.MIN_VALUE;
        {
            int k1 = 2;
            int rest= H - r;
            k1 += rest/(r);
            if (k1 > max) max = k1;
        }
        {
            int k1 = H/r;
            if (k1 > max) max = k1;
        }
        pn(max);
    }

    private static void pn(Object... o1) {
        for (int i = 0; i < o1.length; i++) {
            if (i != 0) out.print(" ");
            out.print(o1[i]);
        }
        out.println();
    }

    private static class LR {
    }

    private static class BR {
        BufferedReader k1 = null;
        StringTokenizer k2 = null;

        public BR() {
            k1 = new BufferedReader(new InputStreamReader(System.in));
        }

        public String nx() throws Exception {
            for (;;) {
                if (k2 == null || !k2.hasMoreTokens()) {
                    String temp = k1.readLine();
                    if (temp == null) return null;
                    k2 = new StringTokenizer(temp);
                }
                else
                    break;
            }

            return k2.nextToken();
        }

        public int ni() throws Exception {
            return Integer.parseInt(nx());
        }
    }

}

import java.util.*;
import java.io.*;

public class C {
/*

 */
    public static BR in;
    public static LR lin;
    public static PrintWriter out;
    public static PrintWriter fout;
    static {
        try {
            in = new BR();
            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out  ) ) );
            fout = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream("output.txt") ) ) );
        }
        catch (Exception e){

        }
    }

    public static boolean bg = true;
    public static void main(String[] args) throws Exception {
        s1();
        out.close();
    }
    private static void s1() throws Exception {
        int r = in.ni();
        int h = in.ni();
        int R = r * 2;
        int H = h * 2;
        int max = Integer.MIN_VALUE;
        {
            int k1 = 2;
            int rest= H - r;
            if (rest >= 0){
                k1 += rest/(r);
                if (k1 > max) max = k1;
            }

        }
        {
            int k1 = H/r;
            if (k1 > max) max = k1;
        }
        {
            int k1 = 3;
            double minus = Math.sqrt(3)*0.5*R+R;
            double remain = H+R - minus;
            if (remain >= 0){
                k1 += (int)Math.floor(remain/r);
                if (k1 > max) max = k1;
            }
        }
        pn(max);
    }

    private static void pn(Object... o1) {
        for (int i = 0; i < o1.length; i++) {
            if (i != 0) out.print(" ");
            out.print(o1[i]);
        }
        out.println();
    }

    private static class LR {
    }

    private static class BR {
        BufferedReader k1 = null;
        StringTokenizer k2 = null;

        public BR() {
            k1 = new BufferedReader(new InputStreamReader(System.in));
        }

        public String nx() throws Exception {
            for (;;) {
                if (k2 == null || !k2.hasMoreTokens()) {
                    String temp = k1.readLine();
                    if (temp == null) return null;
                    k2 = new StringTokenizer(temp);
                }
                else
                    break;
            }

            return k2.nextToken();
        }

        public int ni() throws Exception {
            return Integer.parseInt(nx());
        }
    }

}

import java.util.*;
import java.io.*;

public class C {
/*

 */
    public static BR in;
    public static LR lin;
    public static PrintWriter out;
    public static PrintWriter fout;
    static {
        try {
            in = new BR();
            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out  ) ) );
            fout = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream("output.txt") ) ) );
        }
        catch (Exception e){

        }
    }

    public static boolean bg = true;
    public static void main(String[] args) throws Exception {
        s1();
        out.close();
    }
    private static void s1() throws Exception {
        int r = in.ni();
        int h = in.ni();
        int R = r * 2;
        int H = h * 2;
        int max = Integer.MIN_VALUE;
        {
            int k1 = 2;
            int rest= H - r;
            if (rest >= 0){
                k1 += (rest/R)*2;
                if (k1 > max) max = k1;
            }

        }
        {
            int k1 = (H/R)*2;
            if (k1 > max) max = k1;
        }
        {
            int k1 = 3;
            double minus = Math.sqrt(3)*0.5*R+R;
            double remain = H+R - minus;
            if (remain >= 0){
                k1 += ((int)Math.floor(remain/R))*2;
                if (k1 > max) max = k1;
            }
        }
        pn(max);
    }

    private static void pn(Object... o1) {
        for (int i = 0; i < o1.length; i++) {
            if (i != 0) out.print(" ");
            out.print(o1[i]);
        }
        out.println();
    }

    private static class LR {
    }

    private static class BR {
        BufferedReader k1 = null;
        StringTokenizer k2 = null;

        public BR() {
            k1 = new BufferedReader(new InputStreamReader(System.in));
        }

        public String nx() throws Exception {
            for (;;) {
                if (k2 == null || !k2.hasMoreTokens()) {
                    String temp = k1.readLine();
                    if (temp == null) return null;
                    k2 = new StringTokenizer(temp);
                }
                else
                    break;
            }

            return k2.nextToken();
        }

        public int ni() throws Exception {
            return Integer.parseInt(nx());
        }
    }

}

import java.util.*;
import java.io.*;

public class C {
/*

 */
    public static BR in;
    public static LR lin;
    public static PrintWriter out;
    public static PrintWriter fout;
    static {
        try {
            in = new BR();
            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out  ) ) );
            fout = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream("output.txt") ) ) );
        }
        catch (Exception e){

        }
    }

    public static boolean bg = true;
    public static void main(String[] args) throws Exception {
        s1();
        out.close();
    }
    private static void s1() throws Exception {
        int r = in.ni();
        int h = in.ni();
        int R = r * 2;
        int H = h * 2;
        int max = Integer.MIN_VALUE;
        {
            int k1 = 2;
            int rest= H - r;
            if (rest >= 0){
                k1 += (rest/R)*2;
                if (k1 > max) max = k1;
            }

        }
        {
            int k1 = ((H+r)/R)*2;
            if (k1 > max) max = k1;
        }
        {
            int k1 = 3;
            double minus = Math.sqrt(3)*0.5*R+R;
            double remain = H+R - minus;
            if (Geo.sign(remain) >= 0){
                k1 += ((int)Math.floor(remain/R))*2;
                if (k1 > max) max = k1;
            }
        }
        pn(max);
    }

    private static void pn(Object... o1) {
        for (int i = 0; i < o1.length; i++) {
            if (i != 0) out.print(" ");
            out.print(o1[i]);
        }
        out.println();
    }

    private static class Geo {
        public static double eps = 1e-8;

        public static int sign(double n1) {
            if (Math.abs(n1) <= eps) return 0;
            if (n1 > 0) return 1;
            return -1;
        }
    }
    private static class LR {
    }

    private static class BR {
        BufferedReader k1 = null;
        StringTokenizer k2 = null;

        public BR() {
            k1 = new BufferedReader(new InputStreamReader(System.in));
        }

        public String nx() throws Exception {
            for (;;) {
                if (k2 == null || !k2.hasMoreTokens()) {
                    String temp = k1.readLine();
                    if (temp == null) return null;
                    k2 = new StringTokenizer(temp);
                }
                else
                    break;
            }

            return k2.nextToken();
        }

        public int ni() throws Exception {
            return Integer.parseInt(nx());
        }
    }

}

import java.util.*;
import java.io.*;

public class C {
/*

 */
    public static BR in;
    public static LR lin;
    public static PrintWriter out;
    public static PrintWriter fout;
    static {
        try {
            in = new BR();
            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out  ) ) );
            fout = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream("output.txt") ) ) );
        }
        catch (Exception e){

        }
    }

    public static boolean bg = true;
    public static void main(String[] args) throws Exception {
        s1();
        out.close();
    }
    private static void s1() throws Exception {
        int r = in.ni();
        int h = in.ni();
        int R = r * 2;
        int H = h * 2;
        int max = Integer.MIN_VALUE;
        {
            int k1 = 2;
            int rest= H - r;
            k1 += rest/(r);
            if (k1 > max) max = k1;
        }
        {
            int k1 = H/r;
            if (k1 > max) max = k1;
        }
        {
            int k1 = 3;
            double minus = Math.sqrt(3)*0.5*r+r;
            double remain = H+R - minus;
            k1 += (int)Math.floor(remain/r);
            if (k1 > max) max = k1;
        }
        pn(max);
    }

    private static void pn(Object... o1) {
        for (int i = 0; i < o1.length; i++) {
            if (i != 0) out.print(" ");
            out.print(o1[i]);
        }
        out.println();
    }

    private static class LR {
    }

    private static class BR {
        BufferedReader k1 = null;
        StringTokenizer k2 = null;

        public BR() {
            k1 = new BufferedReader(new InputStreamReader(System.in));
        }

        public String nx() throws Exception {
            for (;;) {
                if (k2 == null || !k2.hasMoreTokens()) {
                    String temp = k1.readLine();
                    if (temp == null) return null;
                    k2 = new StringTokenizer(temp);
                }
                else
                    break;
            }

            return k2.nextToken();
        }

        public int ni() throws Exception {
            return Integer.parseInt(nx());
        }
    }

}

import java.util.*;
import java.io.*;

public class C {
/*

 */
    public static BR in;
    public static LR lin;
    public static PrintWriter out;
    public static PrintWriter fout;
    static {
        try {
            in = new BR();
            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out  ) ) );
            fout = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream("output.txt") ) ) );
        }
        catch (Exception e){

        }
    }

    public static boolean bg = true;
    public static void main(String[] args) throws Exception {
        s1();
        out.close();
    }
    private static void s1() throws Exception {
        int r = in.ni();
        int h = in.ni();
        int R = r * 2;
        int H = h * 2;
        int max = Integer.MIN_VALUE;
        {
            int k1 = 2;
            int rest= H - r;
            if (rest >= 0){
                k1 += rest/(r);
                if (k1 > max) max = k1;
            }

        }
        {
            int k1 = H/r;
            if (k1 > max) max = k1;
        }
        {
            int k1 = 3;
            double minus = Math.sqrt(3)*0.5*r+r;
            double remain = H+R - minus;
            if (remain >= 0){
                k1 += (int)Math.floor(remain/r);
                if (k1 > max) max = k1;
            }
        }
        pn(max);
    }

    private static void pn(Object... o1) {
        for (int i = 0; i < o1.length; i++) {
            if (i != 0) out.print(" ");
            out.print(o1[i]);
        }
        out.println();
    }

    private static class LR {
    }

    private static class BR {
        BufferedReader k1 = null;
        StringTokenizer k2 = null;

        public BR() {
            k1 = new BufferedReader(new InputStreamReader(System.in));
        }

        public String nx() throws Exception {
            for (;;) {
                if (k2 == null || !k2.hasMoreTokens()) {
                    String temp = k1.readLine();
                    if (temp == null) return null;
                    k2 = new StringTokenizer(temp);
                }
                else
                    break;
            }

            return k2.nextToken();
        }

        public int ni() throws Exception {
            return Integer.parseInt(nx());
        }
    }

}

import java.io.*;
import java.util.*;
import java.math.*;

public class Main
{
	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	StringTokenizer tokenizer=null;

	public static void main(String[] args) throws IOException
	{
		new Main().execute();
	}

	void debug(Object...os)
	{
		System.out.println(Arrays.deepToString(os));
	}

	int ni() throws IOException
	{
		return Integer.parseInt(ns());
	}

	long nl() throws IOException
	{
		return Long.parseLong(ns());
	}

	double nd() throws IOException
	{
		return Double.parseDouble(ns());
	}

	String ns() throws IOException
	{
		while (tokenizer == null || !tokenizer.hasMoreTokens())
			tokenizer = new StringTokenizer(br.readLine());
		return tokenizer.nextToken();
	}

	String nline() throws IOException
	{
		tokenizer=null;
		return br.readLine();
	}

	//Main Code starts Here
	int totalCases, testnum;
	int h,r;

	void execute() throws IOException
	{
		totalCases = 1;
		for(testnum = 1; testnum <= totalCases; testnum++)
		{
			if(!input())
				break;
			solve();
		}
	}

	void solve() throws IOException
	{
		int count = 0;
		count = count + (h/r) * 2;
		int left = h % r;

		if ((left - (Math.sqrt(3) * r)/2) > 1e-9) {
			count +=3;
		}
		else {
			count+=2;
		}
		System.out.println(count);

	}

	boolean input() throws IOException
	{
		r = ni();
		h = ni();
		return true;
	}
}

import java.io.*;
import java.util.*;
import java.math.*;

public class Main
{
	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	StringTokenizer tokenizer=null;

	public static void main(String[] args) throws IOException
	{
		new Main().execute();
	}

	void debug(Object...os)
	{
		System.out.println(Arrays.deepToString(os));
	}

	int ni() throws IOException
	{
		return Integer.parseInt(ns());
	}

	long nl() throws IOException
	{
		return Long.parseLong(ns());
	}

	double nd() throws IOException
	{
		return Double.parseDouble(ns());
	}

	String ns() throws IOException
	{
		while (tokenizer == null || !tokenizer.hasMoreTokens())
			tokenizer = new StringTokenizer(br.readLine());
		return tokenizer.nextToken();
	}

	String nline() throws IOException
	{
		tokenizer=null;
		return br.readLine();
	}

	//Main Code starts Here
	int totalCases, testnum;
	int h,r;

	void execute() throws IOException
	{
		totalCases = 1;
		for(testnum = 1; testnum <= totalCases; testnum++)
		{
			if(!input())
				break;
			solve();
		}
	}

	void solve() throws IOException
	{
		int count = 0;
		count = count + (h/r) * 2;
		int left = h % r;

		if ((left - (Math.sqrt(3) * r)/2) > 1e-9) {
			count +=3;
		}
		else if (r/2 == left) {
			count+=2;
		}
		else {
			count+=1;
		}
		System.out.println(count);

	}

	boolean input() throws IOException
	{
		r = ni();
		h = ni();
		return true;
	}
}

import java.io.*;
import java.util.*;
import java.math.*;

public class Main
{
	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	StringTokenizer tokenizer=null;

	public static void main(String[] args) throws IOException
	{
		new Main().execute();
	}

	void debug(Object...os)
	{
		System.out.println(Arrays.deepToString(os));
	}

	int ni() throws IOException
	{
		return Integer.parseInt(ns());
	}

	long nl() throws IOException
	{
		return Long.parseLong(ns());
	}

	double nd() throws IOException
	{
		return Double.parseDouble(ns());
	}

	String ns() throws IOException
	{
		while (tokenizer == null || !tokenizer.hasMoreTokens())
			tokenizer = new StringTokenizer(br.readLine());
		return tokenizer.nextToken();
	}

	String nline() throws IOException
	{
		tokenizer=null;
		return br.readLine();
	}

	//Main Code starts Here
	int totalCases, testnum;
	int h,r;

	void execute() throws IOException
	{
		totalCases = 1;
		for(testnum = 1; testnum <= totalCases; testnum++)
		{
			if(!input())
				break;
			solve();
		}
	}

	void solve() throws IOException
	{
		int count = 0;
		count = count + (h/r) * 2;
		int left = h % r;

		if ((left - (Math.sqrt(3) * r)/2) > 1e-9 && left>0) {
			count +=3;
		}
		else if (r/2 == left && left > 0) {
			count+=2;
		}
		else {
			count+=1;
		}
		System.out.println(count);

	}

	boolean input() throws IOException
	{
		r = ni();
		h = ni();
		return true;
	}
}

import java.io.*;
import java.util.*;
import java.math.*;

public class Main
{
	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	StringTokenizer tokenizer=null;

	public static void main(String[] args) throws IOException
	{
		new Main().execute();
	}

	void debug(Object...os)
	{
		System.out.println(Arrays.deepToString(os));
	}

	int ni() throws IOException
	{
		return Integer.parseInt(ns());
	}

	long nl() throws IOException
	{
		return Long.parseLong(ns());
	}

	double nd() throws IOException
	{
		return Double.parseDouble(ns());
	}

	String ns() throws IOException
	{
		while (tokenizer == null || !tokenizer.hasMoreTokens())
			tokenizer = new StringTokenizer(br.readLine());
		return tokenizer.nextToken();
	}

	String nline() throws IOException
	{
		tokenizer=null;
		return br.readLine();
	}

	//Main Code starts Here
	int totalCases, testnum;
	int h,r;

	void execute() throws IOException
	{
		totalCases = 1;
		for(testnum = 1; testnum <= totalCases; testnum++)
		{
			if(!input())
				break;
			solve();
		}
	}

	void solve() throws IOException
	{
		int count = 0;
		count = count + (h/r) * 2;
		int left = h % r;

		if ((left - (Math.sqrt(3) * r)/2) > 1e-9) {
			count +=3;
		}
		else if (left - r/2.0 > 1e-9) {
			count+=2;
		}
		else {
			count+=1;
		}
		System.out.println(count);

	}

	boolean input() throws IOException
	{
		r = ni();
		h = ni();
		return true;
	}
}

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;
import java.io.Writer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Laputa
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskC {
    public void solve(int testNumber, InputReader cin, OutputWriter out) {
        int rrr=cin.nextInt();
        int hhh=cin.nextInt();
        double R=rrr;
        double H=hhh;

        int ans=Integer.MIN_VALUE;

        double r=R/2;
        double l1=2*R; // 4r
        double l2=R+Math.sqrt(3)*r; //2r+ sqrt3 r
        double l3=R;

        int cnt1=(int)((H+r)/R);
        //int aa=cnt1*4;

        for(int i=0;i<=cnt1;i++){
            //double h1=R*(cnt1-i);
            int tmp=(int)((H+R-R*(cnt1-i))/l2)*3+(cnt1-i)*2;
            ans=Math.max(ans,tmp);
        }

        out.println(ans);
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}

class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void println(Object... objects) {
        print(objects);
        writer.println();
    }

    public void close() {
        writer.close();
    }

    }

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;

import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        new Main().run();
    }

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st = new StringTokenizer("");

    private void run() throws IOException {
//      in = new BufferedReader(new FileReader("input.txt"));
//      out = new PrintWriter("output.txt");

        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(new OutputStreamWriter(System.out));

        solve();
        in.close();
        out.close();
    }

    final double EPS = 0.00000001;
    private void solve() throws IOException {
        double r,h;
        r = nextDouble();
        h = nextDouble();
        double t = 2 * h / r + PI/2;
        int t__ = (int)(t);
        if((t - (double)t__) > r * (sqrt(3) - 1) - EPS)
            t__++;
        out.println(t__);
    }

    String nextToken() throws IOException {
        while (!st.hasMoreTokens())
            st = new StringTokenizer(in.readLine());
        return st.nextToken();
    }
    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
    String nextLine() throws IOException {
        st = new StringTokenizer("");
        return in.readLine();
    }
    boolean EOF() throws IOException {
        while (!st.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null)
                return true;
            st = new StringTokenizer(s);
        }
        return false;
    }
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;

import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        new Main().run();
    }

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st = new StringTokenizer("");

    private void run() throws IOException {
//      in = new BufferedReader(new FileReader("input.txt"));
//      out = new PrintWriter("output.txt");

        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(new OutputStreamWriter(System.out));

        solve();
        in.close();
        out.close();
    }

    final double EPS = 0.00000001;
    private void solve() throws IOException {
        int r = nextInt(), h = nextInt();
        int a = h - h/r;
        out.println( (2 * (h / r) + (((double)a == r/2.0)?2:1)) );
    }

    String nextToken() throws IOException {
        while (!st.hasMoreTokens())
            st = new StringTokenizer(in.readLine());
        return st.nextToken();
    }
    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
    String nextLine() throws IOException {
        st = new StringTokenizer("");
        return in.readLine();
    }
    boolean EOF() throws IOException {
        while (!st.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null)
                return true;
            st = new StringTokenizer(s);
        }
        return false;
    }
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;

import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        new Main().run();
    }

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st = new StringTokenizer("");

    private void run() throws IOException {
//      in = new BufferedReader(new FileReader("input.txt"));
//      out = new PrintWriter("output.txt");

        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(new OutputStreamWriter(System.out));

        solve();
        in.close();
        out.close();
    }

    private void solve() throws IOException {
        while(!EOF()){
            int r = nextInt(), h = nextInt();
            int a = h - r * (int)( ((int)(h/(r/2.0)))/2.0);
//          System.err.println((int)( ((int)(h/(r/2.0)))/2.0));
            if((double)a >= r/2.0)
                a = 2;
            else
                a = 1;
            out.println( (2*(int)( ((int)(h/(r/2.0)))/2.0) + a) );
        }
    }

    String nextToken() throws IOException {
        while (!st.hasMoreTokens())
            st = new StringTokenizer(in.readLine());
        return st.nextToken();
    }
    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
    String nextLine() throws IOException {
        st = new StringTokenizer("");
        return in.readLine();
    }
    boolean EOF() throws IOException {
        while (!st.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null)
                return true;
            st = new StringTokenizer(s);
        }
        return false;
    }
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;

import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        new Main().run();
    }

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st = new StringTokenizer("");

    private void run() throws IOException {
//      in = new BufferedReader(new FileReader("input.txt"));
//      out = new PrintWriter("output.txt");

        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(new OutputStreamWriter(System.out));

        solve();
        in.close();
        out.close();
    }

    private void solve() throws IOException {
        while(!EOF()){
            int r = nextInt(), h = nextInt();
            int a = h % r;
            out.println( (2 * (h / r) + (((double)a == r/2.0)?2:1)) );
        }
    }

    String nextToken() throws IOException {
        while (!st.hasMoreTokens())
            st = new StringTokenizer(in.readLine());
        return st.nextToken();
    }
    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
    String nextLine() throws IOException {
        st = new StringTokenizer("");
        return in.readLine();
    }
    boolean EOF() throws IOException {
        while (!st.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null)
                return true;
            st = new StringTokenizer(s);
        }
        return false;
    }
}

import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Gaoyuan Chen
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskC {
    public void solve(int testNumber, Scanner in, PrintWriter out) {
        int r = in.nextInt(), h = in.nextInt();
        double d = (double)h / (double)r;
        int ans = 1;
        ans = Math.max(ans, 1 + ((int)(d+1-Math.sqrt(3)/2)) * 2);
        ans = Math.max(ans, 2 + ((int)(d-0.5)) * 2);
        out.println(ans);
    }
}

import java.io.*;
import java.util.StringTokenizer;

/**
 * @author kperikov
 */
public class C implements Runnable {

    PrintWriter out;
    BufferedReader br;
    StringTokenizer st;

    public static void main(String[] args) throws IOException {
        new Thread(new C()).start();
    }

    public String next() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(br.readLine());
        }
        return st.nextToken();
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public void run() {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(new BufferedOutputStream(System.out));
            solve();
            out.close();
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
    }

    public void solve() throws IOException {
        int r = nextInt();
        int h = nextInt();
        int ans = 0;
        double left = 0.0d;
        double d1 = r;
        double d2 = (2.0d * r) / (Math.sqrt(2.0d)) + r;
        if (Math.floor(h / d1) * 2 > Math.floor(h / d2) * 5) {
            ans += Math.floor(h / d1) * 2;
            left = h - d1 * Math.floor(h / d1);
        } else {
            ans += Math.floor(h / d2) * 5;
            left = h - d2 * Math.floor(h / d2);
        }
        if (Math.abs(left) <= 1e-7) {
            ans++;
        } else if (left >= r / 2 && left <= (3.0d * r) / 4.0d) {
            ans += 2;
        } else if (left >= (3.0d * r) / 4.0d) {
            ans += 3;
        }
        out.println(ans);
    }
}

import java.io.*;
import java.util.StringTokenizer;

/**
 * @author kperikov
 */
public class C implements Runnable {

    PrintWriter out;
    BufferedReader br;
    StringTokenizer st;

    public static void main(String[] args) throws IOException {
        new Thread(new C()).start();
    }

    public String next() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(br.readLine());
        }
        return st.nextToken();
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public void run() {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(new BufferedOutputStream(System.out));
            solve();
            out.close();
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
    }

    public void solve() throws IOException {
        int r = nextInt();
        int h = nextInt();
        int ans = 0;
        double left;
        double d1 = r;
        double d2 = (2.0d * r) / (Math.sqrt(2.0d)) + r;
        if (Math.floor(h / d1) * 2 > Math.floor(h / d2) * 5) {
            ans += Math.floor(h / d1) * 2;
            left = h - d1 * Math.floor(h / d1);
        } else {
            ans += Math.floor(h / d2) * 5;
            left = h - d2 * Math.floor(h / d2);
        }
        if (Math.abs(left) <= 1e-7) {
            ans++;
        } else if (left >= r / 2.0d && left <= r / Math.sqrt(2.0d) + r) {
            ans += 2;
        } else if (left >= r / Math.sqrt(2.0d) + r) {
            ans += 3;
        }
        out.println(ans);
    }
}

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;

/*
br = new BufferedReader(new FileReader("input.txt"));
pw = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
br = new BufferedReader(new InputStreamReader(System.in));
pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
 */

public class Main {
  private static BufferedReader br;
  private static StringTokenizer st;
  private static PrintWriter pw;

  static String[] list;

  static int[] dx = new int[]{-1,1,0,0};
  static int[] dy = new int[]{0,0,-1,1};

  static char[][] grid;

  public static void main(String[] args) throws IOException {
    br = new BufferedReader(new InputStreamReader(System.in));
    pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    //int qq = 1;
    int qq = Integer.MAX_VALUE;
    //int qq = readInt();
    for(int casenum = 1; casenum <= qq; casenum++)  {
      int r = readInt();
      int h = readInt();
      double height = h + r * Math.sqrt(3) / 2;
      int numCircles = (int)(height/r);
      if(numCircles * r + r * Math.sqrt(3) / 2 <= r+h) {
        numCircles *= 2;
        numCircles++;
      }
      else {
        numCircles *= 2;
      }
      pw.println(numCircles);
    }
    pw.close();
  }

  private static void exitImmediately() {
    pw.close();
    System.exit(0);
  }

  private static long readLong() throws IOException {
    return Long.parseLong(nextToken());
  }

  private static double readDouble() throws IOException {
    return Double.parseDouble(nextToken());
  }

  private static int readInt() throws IOException {
    return Integer.parseInt(nextToken());
  }

  private static String nextToken() throws IOException  {
    while(st == null || !st.hasMoreTokens())  {
      if(!br.ready()) {
        exitImmediately();
      }
      st = new StringTokenizer(br.readLine().trim());
    }
    return st.nextToken();
  }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class C {
	BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter out;

	public void solve() throws IOException {
		int R = nextInt();
		int H = nextInt();
		int ans = 0;
		ans += H/R*2;
		if( H % R >= (double)R/2 ){
			ans += 2;

			double ex = Math.sqrt(3)/2 + (double)R/2;
			double remain = H + R - H/R*R - R;
			if( remain >= ex )  ans+=1;
		}
		else{
			ans += 1;
		}
		out.println( ans );
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new C().run();
	}

	public void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            out = new PrintWriter(System.out);
            solve();
            reader.close();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class Main {

	public static void main(String[] args) {
		try {
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			PrintWriter pw = new PrintWriter(System.out);

			String[] param = br.readLine().split(" ");
			int r = Integer.parseInt(param[0]);
			int h = Integer.parseInt(param[1]);

			int answer = h/r*2;
			if ((h%r/(double)r) > 0.13397459621556124) answer += 2;
			else answer += 1;
			pw.println(answer);

			pw.close();
			br.close();
		} catch (IOException e) {
			e.printStackTrace();
			return;
		}
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class Main {

	public static void main(String[] args) {
		try {
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			PrintWriter pw = new PrintWriter(System.out);

			String[] param = br.readLine().split(" ");
			int r = Integer.parseInt(param[0]);
			int h = Integer.parseInt(param[1]);
			double d = (double)h / r;

			int answer = 0;
			double r3 = Math.sqrt(3.0);
			for (int i = 0; ; i++) {
				double t = r3*i - r3/2.0;
				if (t > d) break;
				answer = Math.max(answer, i*3 + (int)(d-t)*2);
			}

			for (int i = 0; ; i++) {
				double t = r3*i + 1.0-r3/2.0;
				if (t > d) break;
				answer = Math.max(answer, 2+i*3 + (int)(d-t)*2);
			}
			pw.println(answer);

			pw.close();
			br.close();
		} catch (IOException e) {
			e.printStackTrace();
			return;
		}
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class Main {

	public static void main(String[] args) {
		try {
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			PrintWriter pw = new PrintWriter(System.out);

			String[] param = br.readLine().split(" ");
			int r = Integer.parseInt(param[0]);
			int h = Integer.parseInt(param[1]);
			double d = (double)h / r;

			int answer = 0;
			double r3 = Math.sqrt(3.0);
			for (int i = 0; ; i++) {
				double t = r3*i - r3/2.0;
				if (t > d) break;
				answer = Math.max(answer, i*3 + (int)(d-t)*2);
			}

			for (int i = 0; ; i++) {
				double t = r3*i + 0.5;
				if (t > d) break;
				answer = Math.max(answer, 2+i*3 + (int)(d-t)*2);
			}
			pw.println(answer);

			pw.close();
			br.close();
		} catch (IOException e) {
			e.printStackTrace();
			return;
		}
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class Main {

	public static void main(String[] args) {
		try {
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			PrintWriter pw = new PrintWriter(System.out);

			String[] param = br.readLine().split(" ");
			int r = Integer.parseInt(param[0]);
			int h = Integer.parseInt(param[1]);

			int answer = h/r*2;
			if ((h%r/(double)r) > 0.13397459621556135) answer += 2;
			else answer += 1;
			pw.println(answer);

			pw.close();
			br.close();
		} catch (IOException e) {
			e.printStackTrace();
			return;
		}
	}
}

import java.util.Scanner;

public class ce {
	public static void main(String[] args)
	{
		Scanner scan=new Scanner(System.in);
		int r=scan.nextInt();
		int h=scan.nextInt();
		int sum=0;
		sum=2*(h/r);
		h%=r;
		if(h<0.5*r)
			sum++;
		if(h>=0.5*r&&h<Math.sqrt(0.75))
			sum+=2;
		if(h>=Math.sqrt(0.75))
			sum+=3;
		System.out.println(sum);
	}
}

import java.util.*;
public class c {
public static void main(String[] args)
{
    Scanner input = new Scanner(System.in);
    double r = input.nextDouble(), h = input.nextDouble();
    double centerHeight = r/2;
    int count = 2;
    while(centerHeight + r/2 <= h+r - Math.sqrt(3)*r/2)
    {
        centerHeight += r*Math.sqrt(3)/2;
        if(count%3 == 0) count += 2;
        else count++;
    }
    System.out.println(count);
}
}

import java.util.*;
public class c {
public static void main(String[] args)
{
    Scanner input = new Scanner(System.in);
    double r = input.nextDouble(), h = input.nextDouble();
    double centerHeight = r/2;
    int count = 2;
    while(centerHeight + r + r/2 <= h+r*Math.sqrt(3)/2)
    {
        centerHeight += r;
        count += 2;
    }
    if(centerHeight + 3*r/2 <= h+r) count++;
    System.out.println(count);
}
}

import java.util.*;
public class c {
public static void main(String[] args)
{
    Scanner input = new Scanner(System.in);
    double r = input.nextDouble(), h = input.nextDouble();
    double topHeight = 0;
    int count = 0;
    while(topHeight + r <= h+r/2)
    {
        topHeight += r;
        count += 2;
    }
    if(topHeight <= h) count++;

    System.out.println(count);
}
}

import java.util.*;
public class c {
public static void main(String[] args)
{
    Scanner input = new Scanner(System.in);
    double r = input.nextDouble(), h = input.nextDouble();
    double centerHeight = r/2;
    int count = 2;
    while(centerHeight + r + r/2 <= h+r/2)
    {
        centerHeight += r;
        count += 2;
    }
    if(centerHeight + 3*r/2 <= h+r) count++;
    System.out.println(count);
}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Balloons
{
	public static void main(String[] args) throws IOException
	{
		InputStreamReader a = new InputStreamReader(System.in);
		BufferedReader buf = new BufferedReader(a);
		String[] temp = buf.readLine().split(" ");
		int r=Integer.parseInt(temp[0]);
		int h=Integer.parseInt(temp[1]);
		int out=2*h/r;
		double left=h*1.0/r-out/2;
		if (left>=Math.sqrt(3.0)*r/2)
			out+=3;
		else if(left>=r*1.0/2)
			out+=2;
		else
			out++;
		System.out.print(out);
	}
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author Trung Pham
 */
public class C {

    public static void main(String[] args) {
        Scanner in = new Scanner();
        PrintWriter out = new PrintWriter(System.out);
        int r = in.nextInt();
        int h = in.nextInt();
        int result = 2 * (int) Math.ceil((double)h / r);
        //System.out.println(result);
        h -= (int) Math.ceil((double)h / r) * r;
        double val = r * r - (double) (r * r) / 4;
        val = Math.sqrt(val);
        val += r;
       // System.out.println(val + " " + h);
        if (val <= h + 2*r) {
            result++;
        }
        out.println(result);
        out.close();

    }

    static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        } else {
            return gcd(b, a % b);
        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() {
            //System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author Trung Pham
 */
public class C {

    public static void main(String[] args) {
        Scanner in = new Scanner();
        PrintWriter out = new PrintWriter(System.out);
        int r = in.nextInt();
        int h = in.nextInt();
        int result = 0;
        double val = r*r - (double)(r*r)/4;
        val = Math.sqrt(val) + r;
        if(h + r >= val){
            result += 3 + 2*(h + r - val)/r;
        }else{
            if(h >=(double)r/2){
                result = 2;
            }else{
                result = 1;
            }
        }
        out.println(result);
        out.close();

    }

    static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        } else {
            return gcd(b, a % b);
        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() {
            //System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author Trung Pham
 */
public class C {

    public static void main(String[] args) {
        Scanner in = new Scanner();
        PrintWriter out = new PrintWriter(System.out);
        int r = in.nextInt();
        int h = in.nextInt();
        int result = (int) Math.ceil(h / r);
        h -= (h / r) * r;
        double val = r * r - (double) (r * r) / 4;
        val = Math.sqrt(val);
        val += r;
        if(val <= h){
            result++;
        }
        out.println(result);
        out.close();

    }

    static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        } else {
            return gcd(b, a % b);
        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() {
            //System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        try {
            if (new File("input.txt").exists())
                System.setIn(new FileInputStream("input.txt"));
        } catch (SecurityException e) {
        }
        new Main().run();
    }

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st = new StringTokenizer("");

    private void run() throws IOException {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);

        int r = nextInt();
        int h = nextInt();
        int p = h/r;
        p*=2;
        int c = h%r;
        p++;

        double as = (double)r/2;
        int ty = (int)(as+1-0.000001);

        if (c >= ty) p++;

        double as1 = r*3;
        as1 = (double)as1/4;

        //System.err.println(as1);

        int ty1 = (int)(as1+1-0.000001);
    //  System.err.println(ty1);

        //ty1*=3;

        if (c >= ty1) p++;

        out.println(p);

        in.close();
        out.close();
    }

    void chk(boolean b) {
        if (b)
            return;
        System.out.println(new Error().getStackTrace()[1]);
        exit(999);
    }
    void deb(String fmt, Object... args) {
        System.out.printf(Locale.US, fmt + "%n", args);
    }
    String nextToken() throws IOException {
        while (!st.hasMoreTokens())
            st = new StringTokenizer(in.readLine());
        return st.nextToken();
    }
    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
    String nextLine() throws IOException {
        st = new StringTokenizer("");
        return in.readLine();
    }
    boolean EOF() throws IOException {
        while (!st.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null)
                return true;
            st = new StringTokenizer(s);
        }
        return false;
    }
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        try {
            if (new File("input.txt").exists())
                System.setIn(new FileInputStream("input.txt"));
        } catch (SecurityException e) {
        }
        new Main().run();
    }

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st = new StringTokenizer("");

    private void run() throws IOException {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);

        int r = nextInt();
        int h = nextInt();
        int p = h/r;
        p*=2;
        int c = h%r;
        p++;

        double as = (double)r/2;
        int ty = (int)(as+1-0.000001);

        if (c >= ty) p++;

        double as1 = r*3;
        as1 = (double)as1/4;
        int ty1 = (int)(as+1-0.000001);
        ty1*=3;

        if (c >= ty1) p++;

        out.println(p);

        in.close();
        out.close();
    }

    void chk(boolean b) {
        if (b)
            return;
        System.out.println(new Error().getStackTrace()[1]);
        exit(999);
    }
    void deb(String fmt, Object... args) {
        System.out.printf(Locale.US, fmt + "%n", args);
    }
    String nextToken() throws IOException {
        while (!st.hasMoreTokens())
            st = new StringTokenizer(in.readLine());
        return st.nextToken();
    }
    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
    String nextLine() throws IOException {
        st = new StringTokenizer("");
        return in.readLine();
    }
    boolean EOF() throws IOException {
        while (!st.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null)
                return true;
            st = new StringTokenizer(s);
        }
        return false;
    }
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        try {
            if (new File("input.txt").exists())
                System.setIn(new FileInputStream("input.txt"));
        } catch (SecurityException e) {
        }
        new Main().run();
    }

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st = new StringTokenizer("");

    private void run() throws IOException {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);

        int r = nextInt();
        int h = nextInt();
        int p = h/r;
        p*=2;
        int c = h%r;
        p++;
        out.println(p);

        in.close();
        out.close();
    }

    void chk(boolean b) {
        if (b)
            return;
        System.out.println(new Error().getStackTrace()[1]);
        exit(999);
    }
    void deb(String fmt, Object... args) {
        System.out.printf(Locale.US, fmt + "%n", args);
    }
    String nextToken() throws IOException {
        while (!st.hasMoreTokens())
            st = new StringTokenizer(in.readLine());
        return st.nextToken();
    }
    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
    String nextLine() throws IOException {
        st = new StringTokenizer("");
        return in.readLine();
    }
    boolean EOF() throws IOException {
        while (!st.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null)
                return true;
            st = new StringTokenizer(s);
        }
        return false;
    }
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        try {
            if (new File("input.txt").exists())
                System.setIn(new FileInputStream("input.txt"));
        } catch (SecurityException e) {
        }
        new Main().run();
    }

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st = new StringTokenizer("");

    private void run() throws IOException {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);

        int r = nextInt();
        int h = nextInt();
        int p = h/r;
        p*=2;
        int c = h%r;
        p++;

        double as = (double)r/2;
        int ty = (int)(as+1-0.000001);

        if (c >= ty) p++;

        double as1 = r*3;
        as1 = (double)as1/4;
        int ty1 = (int)(as1+1-0.000001);
        ty1*=3;

        if (c >= ty1) p++;

        out.println(p);

        in.close();
        out.close();
    }

    void chk(boolean b) {
        if (b)
            return;
        System.out.println(new Error().getStackTrace()[1]);
        exit(999);
    }
    void deb(String fmt, Object... args) {
        System.out.printf(Locale.US, fmt + "%n", args);
    }
    String nextToken() throws IOException {
        while (!st.hasMoreTokens())
            st = new StringTokenizer(in.readLine());
        return st.nextToken();
    }
    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
    String nextLine() throws IOException {
        st = new StringTokenizer("");
        return in.readLine();
    }
    boolean EOF() throws IOException {
        while (!st.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null)
                return true;
            st = new StringTokenizer(s);
        }
        return false;
    }
}

import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.Math.*;

public class C {
    void solve() {
        double r = sc.nextDouble();
        double h = sc.nextDouble();
        double k = Math.floor(h/r + 0.5);
        double eps = 1e-6;
        double p = 0.0;
        if (h + r - k*r >= (Math.sqrt(3) - 1)*r ) {
            p = 1.0;
        }
        out.print((int) (2.0 * k + p) );
    }

    FastScanner sc;
    PrintWriter out;

    public static void main(String[] args) {
        (new C()).run();
    }

    void run() {
        sc = new FastScanner();
        out = new PrintWriter(System.out);
        solve();
        out.flush();
    }

    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(nextToken());
        }

        long nextLong() {
            return Long.parseLong(nextToken());
        }

        double nextDouble() {
            return Double.parseDouble(nextToken());
        }

        String nextStr() {
            return nextToken();
        }
    }
}

import java.util.*;

public class cf342C{

	public static void main(String args[])
	{

		Scanner sc  = new Scanner(System.in);
		int r = sc.nextInt();
		int h = sc.nextInt();
		int total = 0;
		if(h >= r)
		{
			total += 2*(h/r);
			h= h -(h/r)*r;
		}

		if(2*h >= (int)((Math.sqrt(3))*(float)r))
			total += 3;
		else if(2*h >= r)
			total += 2;
		else
			total += 1;

		System.out.println(total);

	}

}

import java.util.*;

public class cf342C{

	public static void main(String args[])
	{

		Scanner sc  = new Scanner(System.in);
		int r = sc.nextInt();
		int h = sc.nextInt();
		int total = 0;
		if(h >= r)
		{
			total += 2*(h/r);
			h= h -(h/r)*r;
		}

		if(2*h >= r)
			total += 2;
		else
			total += 1;

		System.out.println(total);

	}

}

import java.util.Scanner;

public class C {

    public static void main(String[] args) {
        C solver = new C();
        solver.solve();
    }

    private void solve() {
        Scanner sc = new Scanner(System.in);
//        sc = new Scanner("1 2\n");

        int r = sc.nextInt();
        int h = sc.nextInt();

        int k = 2 * (h / r);
        int p = h - k * r;
        k += 2 * p >= r ? 2 : 1;

        System.out.println(k);
    }

}

import java.util.Scanner;

public class C {

    public static void main(String[] args) {
        C solver = new C();
        solver.solve();
    }

    private void solve() {
        Scanner sc = new Scanner(System.in);
//        sc = new Scanner("1 2\n");

        int r = sc.nextInt();
        int h = sc.nextInt();

        int k = 2 * (h / r);
        int p = h - k * r;

        if (2 * p >= Math.sqrt(3) * r) {
            k += 3;
        } else if (2 * p >= r) {
            k += 2;
        } else {
            k += 1;
        }

        System.out.println(k);
    }

}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Scanner;

public class Solution
{
    public static void main(String ... args) throws Exception
    {
        final double allow = 0.8660254;
        Scanner in = new Scanner(System.in);
        int r = in.nextInt();
        int h = in.nextInt();
        int a = 0;
        int extraspace = h%r;
        //System.out.println("compare " + 2*extraspace + " and " + (r+(double)(r*allow)));
        if(2*extraspace >= r + (double)(r*allow)) a= 3;
        else if(2*(extraspace) >= r) a = 2;
        else a = 1;
        if(h>=r/2) a += 2*(int)(h/r);
        System.out.println(a);
    }
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Scanner;

public class Solution
{
    public static void main(String ... args) throws Exception
    {
        Scanner in = new Scanner(System.in);
        int r = in.nextInt();
        int h = in.nextInt();

        int a = 0;
        if(4*(h%r) >= r) a = 2;
        else a = 1;
        if(h>=r/2) a += 2*(int)(h/r);
        System.out.println(a);
    }
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Scanner;

public class Solution
{
    public static void main(String ... args) throws Exception
    {
        Scanner in = new Scanner(System.in);
        int r = in.nextInt();
        int h = in.nextInt();
        int a = 0;
        if(2*(h%r) >= r) a = 2;
        else a = 1;
        if(h>=r/2) a += 2*(int)(h/r);
        System.out.println(a);
    }
}