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

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

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

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 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.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.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.*;

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

}

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

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

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

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.*;
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.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 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.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.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.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.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.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.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.*;
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);
    }
}