jiahuimbzuai/CoQuIR huggingface dataset:
//  [java]
import java.util.Scanner;

public class Main {

  public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);

    int n = sc.nextInt();
    int d = sc.nextInt() + 1;
    int ans = 0;

    while (d <= n) {
      ans++;
      d *= 2;
    }

    System.out.println(ans);

  }
}
//  [java]
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int D = sc.nextInt();
		int now = D*2+1;
		int count =1;
		while(N>D) {
			now +=D*2+1;
			count++;
		}
		System.out.println(count);
	}
}
//  [cpp]
#include <stdio.h>

int main() {
    int n, d;
    scanf("%d %d", &n, &d);
    
    int l = 1 + (d << 1);
    int res = n / l;
    if (n % l > 0)
        res++;
    printf("%d", res);
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main(){

    int n,d; cin>>n>>d;

    int count=0,rem[n],j=0;

    while(n > 0){

        n -= 2 * d + 1;

        count++;
    }


cout<<count<<endl;

return 0;
}
//  [cpp]
#include <iostream>
#include <math.h>
using namespace std;

int N, D;
int c=0;

int main(){
  if(scanf("%d %d", &N, &D)==0);
  int i=0;
  while((2*D+1)*i<N)i++;
  
  printf("%d", i);
  
  return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define eb emplace_back
#define precision(n) cout << fixed << setprecision(n);
#define fast {ios_base::sync_with_stdio(false);cin.tie(NULL);}
int main()
{
    int n,d;
    int cnt=0;
    cin>>n>>d;
    for(int i=1;i<=n;i++)
    {
        if(i-d>=1&&i+d<=n)
        {
            cnt++;
        }

    }
    cout<<cnt<<endl;
    return 0;
}
//  [cpp]
#pragma GCC optimize("O3")

#define _GLIBCXX_DEBUG
#include <iostream>
#include <vector>
#include <string>
#include <string_view>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <cassert>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
using namespace std;

/*----------macros----------*/

//output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))

//typedef===============
typedef long long       ll;
typedef long double     ld;
typedef vector<int>     Vi;
typedef vector<ll>      Vl;
typedef pair<int, int>  Pii;
typedef pair<ll, ll>    Pll;

//const number==========
constexpr ll INF9   = (ll)1e9 + 1;
constexpr ll INF18  = (ll)1e18 + 1;
constexpr ll MOD1    = 1000000007;
constexpr ll MOD2   = 998244353;
constexpr ld PI     = 3.141592653589793L;

//member================
#define psb push_back
#define epb emplace_back
#define psf push_front
#define mkp make_pair
#define fst first
#define scd second

//others================
#define all(x)          (x).begin(), (x).end()
#define rall(x)         (x).rbegin(), (x).rend()
#define rep(i, n)       for(int i = 0; (i) < (n); ++(i))
#define reps(i, n)      for(int i = 1; (i) <= (n); ++(i))
#define rrep(i, n)      for(int i = n - 1; (i) >= 0 ; --(i))
#define repbit(bit, n)  for(int bit = 0; (bit) < (1 << (n)); ++(bit))
#define ifbit(bit, i)   if((bit) & (1 << (i)))
#define CtoI(c)         int((c)) - int('0')
#define ItoC(c)         char((c) + '0')

//functions=============
template<typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }

template<typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }

//vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
//vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };

/*--------additional--------*/



/*----------main------------*/

int main() {
/*----------fastio----------*/
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    std::ios::sync_with_stdio(false);
/*----------solve-----------*/

    int n, d; cin >> n >> d;
    cout << n/((d+1)*2) + 1 << endl;

return 0;
}
//  [cpp]
#pragma GCC optimize("O3")

#define _GLIBCXX_DEBUG
#include <iostream>
#include <vector>
#include <string>
#include <string_view>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <cassert>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
using namespace std;

/*----------macros----------*/

//output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))

//typedef===============
typedef long long       ll;
typedef long double     ld;
typedef vector<int>     Vi;
typedef vector<ll>      Vl;
typedef pair<int, int>  Pii;
typedef pair<ll, ll>    Pll;

//const number==========
constexpr ll INF9   = (ll)1e9 + 1;
constexpr ll INF18  = (ll)1e18 + 1;
constexpr ll MOD1    = 1000000007;
constexpr ll MOD2   = 998244353;
constexpr ld PI     = 3.141592653589793L;

//member================
#define psb push_back
#define epb emplace_back
#define psf push_front
#define mkp make_pair
#define fst first
#define scd second

//others================
#define all(x)          (x).begin(), (x).end()
#define rall(x)         (x).rbegin(), (x).rend()
#define rep(i, n)       for(int i = 0; (i) < (n); ++(i))
#define reps(i, n)      for(int i = 1; (i) <= (n); ++(i))
#define rrep(i, n)      for(int i = n - 1; (i) >= 0 ; --(i))
#define repbit(bit, n)  for(int bit = 0; (bit) < (1 << (n)); ++(bit))
#define ifbit(bit, i)   if((bit) & (1 << (i)))
#define CtoI(c)         int((c)) - int('0')
#define ItoC(c)         char((c) + '0')

//functions=============
template<typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }

template<typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }

//vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
//vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };

/*--------additional--------*/



/*----------main------------*/

int main() {
/*----------fastio----------*/
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    std::ios::sync_with_stdio(false);
/*----------solve-----------*/

    int n, d; cin >> n >> d;
    cout << floor(n/((d+1)*2)) + 1 << endl;

return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <math.h>

int main(void)
{
    int n, d, ret;
    scanf("%d%d", &n, &d);
    if(n%(2*d+1)==0) ret=n/(2*d+1);
    else ret=n/(2*d+1)+1;

    printf("%d", ret);

    return 0;
}
//  [c]
#include <stdio.h>

int main(void) {
    int n, d, ans = 1;
    scanf("%d%d", &n, &d);
    int monitor_man         = d + 1;
    int monitor_range_right = monitor_man + d;
    while ( monitor_range_right < n ) {
        ans++;
        monitor_man += (2 * d + 1);
        monitor_range_right = monitor_man + d;
    }
    printf("%d\n", ans);
    return 0;
}
//  [c]
#include <stdio.h>

int main()
{
    int n, d , a;
    scanf("%d %d", &n, &d);
    d = d * 2 + 1;
    a = n % d;
    if(a)
     a = 1;
    printf("%d", n / d + a);
}
//  [c]
#niclude<stdio.h>
int main(){
  int n,d;
  scanf("%d%d",&n,&d);
  int k;
  k=2*d+1;
  if(n%k==0)
    printf("%d",n/k);
  else
    printf("%d",n/k+1);
}
//  [c]
/*  ex5_2
    L40S38  */
#include<stdio.h>

int main(void){
    int tribonacci[1000000];
    int n;
    scanf("%d",&n);
    tribonacci[0]=0;
    tribonacci[1]=0;
    tribonacci[2]=1;
    if(n>3){
        for(int i=2;i<n-1;i++){
            tribonacci[i+1]=tribonacci[i]+tribonacci[i-1]+tribonacci[i-2];
        }
    }
    printf("%d\n",tribonacci[n-1]);
    return 0;
}
//  [c]
#include <stdio.h>

int main(){
  int n,d;
  scanf("%d%d",&n,&d);
  
  int a = n / (2*d);
  int b = n % (2*d);
  if(b>=d) a++;
  
  printf("%d",a);
}
//  [javascript]
input = require('fs').readFileSync('/dev/stdin', 'utf8')  
N = input.split(' ')[0] * 1
D = input.split(' ')[1] * 1
console.log(Math.ceil(N / (D * 2 + 1)))
//  [javascript]
const input = require('fs').readFileSync('/dev/stdin','utf8').split("\n")[0]
const lst = input.split(" ").map(x => Number(x))
const N = lst[0]
const D = lst[1]
console.log(Math.floor((N+D*2)/(D*2+1)))
//  [javascript]
function Main(input) {
  	var inputArray = input.split(' ');
    var appleN = inputArray[0];
    var lookD = inputArray[1] * 2 + 1;
    var ans = appleN / lookD;
    if (appleN % lookD != 0) {
       console.log(Math.floor(ans + 1));
        } else {
  		 console.log(ans);
        }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict';
function main(input) {
  const arr = input.trim().split(' ');
  const a = Number(arr[0]);
  const b = Number(arr[1]);
  
  console.log(Math.ceil(a / (b * 2)));
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	input = input.split(" ").map(Number);
	console.log(Math.ceil(input[0]/(input[1]+1)))

}Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
function Main(input) {
	input = input.split(" ").map(Number);
	console.log(math.ceil(input[0]/(input[1]+1)))

}Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [go]
package main

import "fmt"

func main() {
	var N, D int
	fmt.Scanf("%d %d", &N, &D)
	n := 2*D + 1
	ans := 1
	N -= n
	for N >= 1 {
		N -= n
		ans++
	}
	fmt.Println(ans)
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	In := readLineInt()
	N, D := In[0], In[1]

	i := 1
	for {
		if 2*D*i+i >= N {
			fmt.Println(i)
			return
		}
		i++
	}
}

/////////////////////////////////////////

func readLineInt() []int {
	result := make([]int, 0)
	for _, v := range strings.Split(readLine(), " ") {
		i, _ := strconv.Atoi(v)
		result = append(result, i)
	}
	return result
}

var reader = bufio.NewReaderSize(os.Stdin, 1e6)

func readLine() string {
	result := make([]byte, 0, 1e6)
	for {
		line, remains, e := reader.ReadLine()
		if e != nil {
			panic(e)
		}
		result = append(result, line...)
		if !remains {
			break
		}
	}
	return string(result)
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"strconv"
	"strings"
)

func main() {
	ints := readLineAsInts()
	fmt.Println(math.Ceil(float64(ints[0]) / float64(2*ints[1]+1)))
}

func toInt(s string) int {
	i, e := strconv.Atoi(s)
	if e != nil {
		fmt.Println(e)
	}
	return i
}

func nextLine(scanner *bufio.Scanner) string {
	scanner.Scan()
	return scanner.Text()
}

func readInt() int {
	var scanner = bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	return toInt(nextLine(scanner))
}

func readStr() string {
	var scanner = bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	return nextLine(scanner)
}

func readLineAsStr() string {
	var scanner = bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanLines)
	return nextLine(scanner)
}

func readLineAsInts() []int {
	var scanner = bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanLines)
	s := strings.Split(nextLine(scanner), " ")
	ints := make([]int, len(s))
	for i, str := range s {
		ints[i] = toInt(str)
	}
	return ints
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

const (
	defaultBufferSize = 1024
	maxBufferSize     = 1e6
	Mod               = 1e9 + 7
)

var sc = bufio.NewScanner(os.Stdin)

// sc.Buffer(make([]byte, defaultBufferSize), maxBufferSize)

func readInt() int {
	sc.Scan()
	i, err := strconv.Atoi(sc.Text())
	if err != nil {
		panic(err)
	}
	return i
}

func readString() string {
	sc.Scan()
	return sc.Text()
}

func readInt64() int64 {
	sc.Scan()
	i, err := strconv.ParseInt(sc.Text(), 10, 64)
	if err != nil {
		panic(err)
	}
	return int64(i)
}

func readfloat64() float64 {
	sc.Scan()
	f, err := strconv.ParseFloat(sc.Text(), 64)
	if err != nil {
		panic(err)
	}
	return f
}

func abs(a int) int {
	if a < 0 {
		return a * -1
	}
	return a
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func gcd(x, y int) int {
	if y == 0 {
		return x
	}
	return gcd(y, x%y)
}

func ModComb(n, k int) int {
	if k == 0 {
		return 1
	}
	x, y := n, k
	for i := 1; i < k; i++ {
		x = x * (n - i) % Mod
		y = y * (k - i) % Mod
	}
	inv := ModInv(y)
	return x * inv % Mod
}

func ModFact(x int) int {
	fact := 1
	for i := 1; i <= x; i++ {
		fact = fact * i % Mod
	}
	return fact
}

func ModInv(x int) int {
	return ModPow(x, Mod-2)
}

func ModPow(a, n int) int {
	res := 1
	for n > 0 {
		if n%2 != 0 {
			res = res * a % Mod
		}
		a = a * a % Mod
		n /= 2
	}
	return res
}

func pow(a, n int) int {
	if n == 0 {
		return 1
	}

	ans := 0
	if n%2 == 0 {
		ans = pow(a*a, n/2)
	} else {
		ans = a * pow(a*a, (n-1)/2)
	}
	return ans
}

func intSliceReverse(slice []int) []int {
	for i, j := 0, len(slice)-1; i < j; i, j = i+1, j-1 {
		slice[i], slice[j] = slice[j], slice[i]
	}
	return slice
}

func stringReverse(str string) string {
	runes := []rune(str)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func primeFactorization(x int) map[int]int {
	result := make(map[int]int, 0)
	for i := 2; i*i <= x; i++ {
		for x%i == 0 {
			result[i]++
			x /= i
		}
	}
	if x != 1 {
		result[x]++
	}
	return result
}

func isPrime(x int) bool {
	if x == 1 {
		return false
	}
	for i := 2; i*i <= x; i++ {
		if i == x {
			continue
		}
		if x%i == 0 {
			return false
		}
	}
	return true
}

func main() {
	sc.Split(bufio.ScanWords)
	n, d := readInt(), readInt()

	if d > n {
		fmt.Println(1)
		return
	}

	ans := 0
	for i := d; i <= n; i = i + d + d {
		ans++
	}
	fmt.Println(ans)
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

const (
	defaultBufferSize = 1024
	maxBufferSize     = 1e6
	Mod               = 1e9 + 7
)

var sc = bufio.NewScanner(os.Stdin)

// sc.Buffer(make([]byte, defaultBufferSize), maxBufferSize)

func readInt() int {
	sc.Scan()
	i, err := strconv.Atoi(sc.Text())
	if err != nil {
		panic(err)
	}
	return i
}

func readString() string {
	sc.Scan()
	return sc.Text()
}

func readInt64() int64 {
	sc.Scan()
	i, err := strconv.ParseInt(sc.Text(), 10, 64)
	if err != nil {
		panic(err)
	}
	return int64(i)
}

func readfloat64() float64 {
	sc.Scan()
	f, err := strconv.ParseFloat(sc.Text(), 64)
	if err != nil {
		panic(err)
	}
	return f
}

func abs(a int) int {
	if a < 0 {
		return a * -1
	}
	return a
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func gcd(x, y int) int {
	if y == 0 {
		return x
	}
	return gcd(y, x%y)
}

func ModComb(n, k int) int {
	if k == 0 {
		return 1
	}
	x, y := n, k
	for i := 1; i < k; i++ {
		x = x * (n - i) % Mod
		y = y * (k - i) % Mod
	}
	inv := ModInv(y)
	return x * inv % Mod
}

func ModFact(x int) int {
	fact := 1
	for i := 1; i <= x; i++ {
		fact = fact * i % Mod
	}
	return fact
}

func ModInv(x int) int {
	return ModPow(x, Mod-2)
}

func ModPow(a, n int) int {
	res := 1
	for n > 0 {
		if n%2 != 0 {
			res = res * a % Mod
		}
		a = a * a % Mod
		n /= 2
	}
	return res
}

func pow(a, n int) int {
	if n == 0 {
		return 1
	}

	ans := 0
	if n%2 == 0 {
		ans = pow(a*a, n/2)
	} else {
		ans = a * pow(a*a, (n-1)/2)
	}
	return ans
}

func intSliceReverse(slice []int) []int {
	for i, j := 0, len(slice)-1; i < j; i, j = i+1, j-1 {
		slice[i], slice[j] = slice[j], slice[i]
	}
	return slice
}

func stringReverse(str string) string {
	runes := []rune(str)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func primeFactorization(x int) map[int]int {
	result := make(map[int]int, 0)
	for i := 2; i*i <= x; i++ {
		for x%i == 0 {
			result[i]++
			x /= i
		}
	}
	if x != 1 {
		result[x]++
	}
	return result
}

func isPrime(x int) bool {
	if x == 1 {
		return false
	}
	for i := 2; i*i <= x; i++ {
		if i == x {
			continue
		}
		if x%i == 0 {
			return false
		}
	}
	return true
}

func main() {
	sc.Split(bufio.ScanWords)
	n, d := readInt(), readInt()

	ans := 0
	for i := d; i <= n; i = i + d + d {
		ans++
	}
	fmt.Println(ans)
}
//  [ruby]
N,D = gets.split.map(&:to_i)
num = 1
left = 1
right = left + D + D
loop do
    break if right >= N
    num += 1
    left = right + 1
    right = left + D + D
end
puts num
//  [ruby]
N, D = gets.split.map(&:to_i)
puts (N/(D*2+1.0)).ceil
//  [ruby]
line = gets.split(' ').map(&:to_i)

N = line[0]
D = line[1]

if N % (2 * D + 1) == 0 then
  print N / (2 * D + 1)
else
  print N / (2 * D + 1) + 1
end
//  [ruby]
n, d = gets.chomp.split(" ").map(&:to_i)
puts n / ( 2 * d + 1)
//  [ruby]
line = gets.split(' ').map(&:to_i)

N = line[0]
D = line[1]

if N % (2 * D +1) == 0 then
  print N / (2 * D + 1)
else
  print N / (2 * D + 1) + 1
end
//  [ruby]
line = gets.split(' ').map(&:to_i)
N = line[0]
D = line[1]
hanni = 2*D
if N%hanni== 0 then
  puts(N/hanni)
else
  puts(N/hanni+1)
end
//  [rust]
use std::io;

fn main() {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let mut iter = buf.split_whitespace();
	let n = match iter.next().unwrap().parse::<i32>() {
		Ok(m) => m,
		_ => panic!(""),
	};
	let d = match iter.next().unwrap().parse::<i32>() {
		Ok(m) => m,
		_ => panic!(""),
	};
	println!("{}", (n+2*d)/(2*d + 1));
}
//  [rust]
#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

#[allow(unused_macros)]
macro_rules! debug {
    ($($a:expr),*) => {
        eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}


fn f(s: &Vec<i32>) -> bool{

    


    return true;
}

use std::iter::Iterator;
use std::cmp;


fn main() {
    input! {
       n : i32,
        d : i32
    }

    let mut cnt = 0;
    let mut target = n;
    for i in 0..20 {
        
        target = target - (d * 2 + 1);
        cnt = cnt + 1;

        if target <= 0 {
            break;
        }
    }

    println!("{}", cnt);


}
//  [rust]
use std::io::Read;

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();
    let n: usize = iter.next().unwrap().parse().unwrap();
    let d: usize = iter.next().unwrap().parse().unwrap();

    println!("{}", (n - 1) / (2 * d + 1) + 1);
}
//  [rust]
use std::io;

fn main() {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let mut iter = buf.split_whitespace();
	let n = match iter.next().unwrap().parse::<i32>() {
		Ok(m) => m,
		_ => panic!(""),
	};
	let d = match iter.next().unwrap().parse::<i32>() {
		Ok(m) => m,
		_ => panic!(""),
	};
	let mut cnt = 1;
	let mut i = 1;
	if i < n {
		i = i + 2*d + 1;
		cnt += 1;
	}
	println!("{}", cnt);
}
//  [rust]
use proconio::input;

fn main() {
    input! {
        n: usize, d: usize,
    }
    let d = 2 * d + 1;
    println!("{}", (n+d-1)/d);
}
//  [rust]
fn read_vec2<T: std::str::FromStr>(n: u32) -> Vec<Vec<T>> {
    let mut v2 = Vec::new();
    for _ in 0..n {
        let mut s = String::new();
        std::io::stdin().read_line(&mut s).ok();
        let v = s.trim().split_whitespace()
            .map(|e| e.parse().ok().unwrap()).collect();
        v2.push(v);
    }
    v2
}
fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().split_whitespace()
        .map(|e| e.parse().ok().unwrap()).collect()
}

fn main(){
    let stdin = read_vec::<isize>();
    let (n, d)=(stdin[0], stdin[1]);
    let a = n/(d*2+1);
    let amari = {
        if n%(d*2)==0{
            0
        }else{
            1
        }
    };

    println!("{:?}", a+amari);
}
//  [swift]
func readInts() -> [Int]{
    return readLine()!.split(separator: " ").map{Int($0)!};
}
let a = readInts();
let N = a[0];
let D = a[1];
print(N / (2 * D + 1) + (N % (2 * D + 1) + 2 * D) / (2 * D + 1))
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
let nd=readInts()
let n=nd[0]
let d=nd[1]
print(Int((n+2*d)/(2*d+1)))
//  [swift]
import Foundation

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

let nd=readInts()
let n:Double=Double(nd[0])
let d:Double=Double(nd[1])

print(Int(ceil(n/(2*d+1))))
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
let nd=readInts()
let n=nd[0]
let d=nd[1]
print(Int(n/(2*d+1))+1)
//  [typescript]
const main = (lines: string) => {
  const data = lines.split(" ");
  const treeSize = parseInt(data[0], 10);
  const coverableRange = parseInt(data[1], 10) * 2 + 1;

  console.log(Math.ceil(treeSize / coverableRange));
};

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
import * as fs from 'fs';

namespace AtCoder.abc134 {
    class ProgramB {
        args: string[];

        // 6 2
        // 2
        constructor(args: string[]) {
            this.args = args;
        }

        main() {
            const [n, d]: number[] = this.args[0].split(' ').map(x => parseInt(x, 10));

            const ans: number = (n % (d * 2 + 1) > 0) ? Math.floor(n / (d * 2 + 1) + 1) : n / (d * 2 + 1);
            console.log(ans);

        }
    }

    const args: string[] = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n');
    new ProgramB(args).main();
}
//  [typescript]
import * as fs from "fs";

const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
//const n = +input[0];
//const a = [];
//for(let i=0;i<n;i++){
//	a.push(input[i+1].split(" ").map((x:string):number=>+x));
//}

//const [n, m] = input[0].split(" ").map((x: string): number => +x);
//const a = input[1].split(" ").map((x: string): number => +x);

function compareFunc(a, b){
    return a-b;
}

const [n, d] = input[0].split(' ').map((x: string): number => +x);

const kanshi:number = d*2 +1;

if(n % kanshi === 0){
    console.log(n/kanshi);
}else{
    console.log(Math.floor(n/kanshi)+1);
}
//  [typescript]
process.stdin.resume();
process.stdin.setEncoding('utf8');

var lines = [];
var reader = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});
reader.on('line', (line) => {
  lines.push(line);
});
reader.on('close', () => {
  const [N, D] = lines[0].split(" ").map(Number);

  if (N === 1) {
    console.log(1);
  } else if (D === 1) {
    console.log(1);
  } else if (D === 2) {
    console.log(2);
  } else {
    console.log(D - 1);
  }
});
//  [typescript]
process.stdin.resume();
process.stdin.setEncoding('utf8');

var lines = [];
var reader = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});
reader.on('line', (line) => {
  lines.push(line);
});
reader.on('close', () => {
  const [N, D] = lines[0].split(" ").map(Number);
  console.log(D > 1 ? D - 1 : D);
});
//  [typescript]
process.stdin.resume();
process.stdin.setEncoding('utf8');

var lines = [];
var reader = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});
reader.on('line', (line) => {
  lines.push(line);
});
reader.on('close', () => {
  const [N, D] = lines[0].split(" ").map(Number);
  console.log(D - 1);
});
//  [python]
a,b,c,d = map(int, input().split())

while True:
    c -= b
    if c <= 0:
        print("Yes")
        exit()
    a -= d
    if a <= 0:
        print("No")
        exit()
//  [python]
a,b,c,d = map(int,input().split())
taka = [a,b]
ao = [c,d]
flag = True

while a > 0 or c > 0:
    c -= b
    if c <= 0:
        break
    a -= d
    if a <= 0:
        flag = False
        break

if flag:
    print("Yes")
else:
    print("No")
//  [python]
def resolve():
    a, b, c, d = map(int, input().split())
    takahashiturn = True
    while a > 0 and c > 0:
        if takahashiturn:
            c -= b
            takahashiturn = False
        else:
            a -= d
            takahashiturn = True
    print("Yes" if c <= 0 else "No")


if __name__ == '__main__':
    resolve()
//  [python]
# 高橋君のモンスター　体力A、攻撃力B
# 青木君のモンスター　体力C、攻撃力D
# 高橋->青木->高橋->青木->...の順に攻撃する
# 高橋勝つならYes、負けるならNo

a, b, c, d = map(int, input().split())

while a > 0 and c > 0:
    c -= b
    if c <= 0:
        print("Yes")
        break

    a -= d
    if d <= 0:
        print("No")
        break
//  [python]
# 高橋君のモンスター　体力A、攻撃力B
# 青木君のモンスター　体力C、攻撃力D
# 高橋->青木->高橋->青木->...の順に攻撃する
# 高橋勝つならYes、負けるならNo

a, b, c, d = map(int, input().split())

while a > 0 and c > 0:
    c -= b
    if c <= 0:
        print("Yes")

    a -= d
    if d <= 0:
        print("No")
//  [python]
A, B, C, D = map(int,input().split())

while C > 0:
    C = C - B
    if C <= 0:
        print('Yes')
        break

while A > 0:
    A = A - D
    if A <= 0:
        print('No')
        break
//  [java]
import java.util.*;
import java.io.*;

public class Main {	

	private static void solve(){
		//Implement solution here.
		int A = ni();
		int B = ni();
		int C = ni();
		int D = ni();
		int turn_1 = C / B + (C % B != 0 ? 1 : 0);
		int turn_2 = A / D + (A % D != 0 ? 1 : 0);
		System.out.println(turn_1 <= turn_2 ? "Yes" : "No");
	}

	//Switch input source (stdin/file)
	private static BufferedReader br;
	public static void main(String[] args){
		br = new BufferedReader(new InputStreamReader(System.in));
		String debugDataPath = System.getenv("DD_PATH");        
		if(debugDataPath != null){
			try{
				br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(debugDataPath))));
			}catch(Exception e){
				throw new RuntimeException(e);
			}
		}
		boolean hasNext = true;
		while(hasNext){
			solve();	
			try{
				br.mark(1);
				if(br.read() > 0){
					br.reset();			
					System.out.println("---");
				} else {
					hasNext = false;
				}
			}catch(Exception e){
				throw new RuntimeException(e);
			} 
		}
	}

	//Input read utility
	private static StringTokenizer tokenizer = null;
	public static String next() {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(br.readLine());
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}
	//Get next single int
	private static int ni() {
		return Integer.parseInt(next());
	}
	//Get next single long
	private static long nl() {
		return Long.parseLong(next());
	}
	//Get next single double
	private static double nd() {
		return Double.parseDouble(next());
	}
	//Get next int array from one line
	private static int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}
	//Get next char array from one line
	private static char[] ns() {
		return next().toCharArray();
	}
	//Get next long array from one line
	private static long[] nal(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nl();
		return a;
	}
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main
{
	public static void main(String[] Arguments) throws IOException 
	{
		BufferedReader BR = new BufferedReader(new InputStreamReader(System.in)); StringTokenizer ST = new StringTokenizer(BR.readLine());
		int A = Integer.parseInt(ST.nextToken()), B = Integer.parseInt(ST.nextToken()), C = Integer.parseInt(ST.nextToken()), D = Integer.parseInt(ST.nextToken());
		boolean takaTurn = true;
		while (A > 0 && C > 0)
		{
			if (takaTurn) C -= B;
			else A -= D;
			takaTurn = !takaTurn;
		}
		System.out.println((A > 0) ? "Yes" : "No");
	}
}
//  [java]
import java.util.*;

class Main{
    public static void main(String[] args){
        // 入力受付
        Scanner sc = new Scanner(System.in);    //scanner
        int A = sc.nextInt();
        int B = sc.nextInt();
        int C = sc.nextInt();
        int D = sc.nextInt();

        // バトル
        while(true){
            // 高橋くんの攻撃
            C-=B;
            if(C<0){
                System.out.println("Yes");
                break;
            }
            // 青木くんの攻撃
            A-=D;
            if(A<0){
                System.out.println("No");
                break;
            }
        }
    }
}
//  [java]
import java.util.*;

class Main{
    public static void main(String[] args){
        // 入力受付
        Scanner sc = new Scanner(System.in);    //scanner
        int A = sc.nextInt();
        int B = sc.nextInt();
        int C = sc.nextInt();
        int D = sc.nextInt();

        // バトル
        while(true){
            // 高橋くんの攻撃
            C-=B;
            if(C<0){
                System.out.println("Yes");
            }
            // 青木くんの攻撃
            A-=D;
            if(A<0){
                System.out.println("No");
                break;
            }
        }
    }
}
//  [java]
import java.util.*;

class Main{
    public static void main(String[] args){
        // 入力受付
        Scanner sc = new Scanner(System.in);    //scanner
        int A = sc.nextInt();
        int B = sc.nextInt();
        int C = sc.nextInt();
        int D = sc.nextInt();

        // 計算
        if( (A+D-1)/D >= (C+B-1)/B)
            System.out.println("Yes");
        else
            System.out.println("Yes");
    }
}
//  [cpp]
#define FOR(i, a, b) for(int i=a; i<b; i++)
#include<cstdio>
#include<algorithm>
#include<utility>
#include<string>
#include<cstdlib>

int main(){
    int a, b, c, d;
    scanf("%d %d %d %d", &a, &b, &c, &d);

    while(true){
        c -= b;
        if(c<=0){
            printf("Yes\n");
            break;
        }
        a -= d;
        if(a<=0){
            printf("No\n");
            break;
        }
    }

    return 0;
}
//  [cpp]
#include<cstdio>
#include<algorithm>
using namespace std;
int main(void){
	int a,b,c,d,T,A;
	scanf("%d %d %d %d",&a,&b,&c,&d);
	T=c/b;
	A=a/d;
	if(c%b!=0){
		T++;
	}
	if(a%d!=0){
		A++;
	}
	if(T<=A){
		printf("Yes\n");
	}
	else{
		printf("No\n");
	}
	return 0;
}
//  [cpp]
#include<stdio.h>
int main()
{
    int a,b,c,d,turn = 0;
    scanf("%d %d %d %d",&a,&b,&c,&d);
    while(1)
    {
        turn++;
        if(turn%2!=0) //odd-taka attacks
            c = c-b;
        else //even - ako attacks
            a = a-d;
        if(a<=0 || c<=0)
            break;
    }
    if(a>=c)puts("Yes");
    else puts("No");
    return 0;
}
//  [cpp]
#include <iostream>
#include <bits/stdc++.h>

using namespace std;

int main()
{
    int a,b,c,d;
    cin>>a>>b>>c>>d;
    int tpoints=0,apoints=0;
    if(a<c){
        apoints++;
    }
    else if(a>c){
        tpoints++;
    }
    if(b<d){
        apoints++;
    }
    else if(b>d){
        tpoints++;
    }
    if(tpoints>=apoints){
        cout<<"Yes";
    }
    else{
        cout<<"No";
    }
    return 0;
}
//  [cpp]
#include <iostream>
#include <bits/stdc++.h>

using namespace std;

int main()
{
    int a,b,c,d;
    cin>>a>>b>>c>>d;
    if(a+b < c+d){
        cout<<"No";
    }
    else{
        cout<<"Yes";
    }

    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
const long long MOD = 1e9+7;
using namespace std;
#define ll long long
#define ar array

int main () {
	ios::sync_with_stdio(0);
	cin.tie(0);

	int a,b,c,d;
	cin >> a >> b >> c >> d;

	if ((b-c)>(d-a)) {
		cout << "Yes" << endl;
	} else {
		cout << "No" << endl;
	}
	return 0;
}
//  [c]
#include<stdio.h>
int main(void){
  int a,b,c,d;
  scanf("%d%d%d%d",&a,&b,&c,&d);
  while(1){
    c-=b;
    if(c<=0){printf("Yes");
             return 0;
            }
    a-=d;
    if(a<=0){printf("No");
            return 0;
           }
  }
  return 0;
}
//  [c]
#include <stdio.h>

int main(void) {
    int A, B, C, D, b;
    scanf("%d%d%d%d", &A, &B, &C, &D);
    while (1) {
        C-=B;
        if (C<=0) {
            b=1;
            break;
        }
        A-=D;
        if (A<=0) {
            b=0;
            break;
        }
    }
    if (b) printf("Yes");
    else printf("No");
    return 0;
}
//  [c]
#include <stdio.h>

int main(void){
    int a,b,c,d;
    scanf("%d %d %d %d",&a,&b,&c,&d);
    while(a>0 || c>0){
        c-=b;
        if(c<=0){
            break;
        }
        a-=d;
    }
    if(a>0){
        printf("Yes\n");
    }else{
        printf("No\n");
    }
    return 0;
}
//  [c]
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<time.h>
#define FOR(i,n) for(int i=0;i<n;i++)
#define PRN(n) printf("%d\n",n)
#define PRF(n) printf("%lf\n",n)
#define PRL(n) printf("%lld\n",n)
#define PRS(s) printf("%s\n",s)
#define PRC(c) printf("%c",c)
#define INI(n) scanf("%d",&n)
#define INL(n) scanf("%lld",&n)
#define INF 10000000000
#define mod 1000000007
#define X 100000
#define N 20
#define M 46
typedef long long int ll;
ll finv[X];
ll fac[X];
ll inv[X];
ll usort(const void *a, const void *b){return *(ll*)a-*(ll*)b;}
ll dsort(const void *a, const void *b){return *(ll*)b-*(ll*)a;}
ll ssort(const void *a, const void *b){return strcmp((char*)a,(char*)b);}
void Iswap(int *a,int *b){
  int t=*a;
  *a=*b;
  *b=t;
}
void Fswap(double *a,double *b){
  double t=*a;
  *a=*b;
  *b=t;
}
void Lswap(ll *a,ll *b){
  ll t=*a;
  *a=*b;
  *b=t;
}
ll min(ll a,ll b){
  if(a>b)return b;
  return a;
}
ll max(ll a,ll b){
  if(a>b)return a;
  return b;
}
ll z(ll a){return max(a,-a);}
ll gcd(ll a,ll b){if(!b){return a;}else{return gcd(b,a%b);}}
ll lcm(ll a,ll b){return a*b/gcd(a,b);}
ll kt(ll a){
  ll sum=0;
  while(a){
    a/=10;
    sum++;
  }
  return sum;
}
ll ks(ll a){
  ll sum=0;
  while(a){
    sum+=a%10;
    a/=10;
  }
  return sum;
}
void nCrReady(){
  fac[0]=fac[1]=1;
  finv[0]=finv[1]=1;
  inv[1]=1;
  for (ll i=2;i<X;i++){
    fac[i]=fac[i-1]*i%mod;
    inv[i]=mod-inv[mod%i]*(mod/i)%mod;
    finv[i]=finv[i-1]*inv[i]%mod;
  }
}
ll nCr(ll n,ll k){return fac[n]*(finv[k]*finv[n-k]%mod)%mod;}
ll modpow(ll a,ll n){
  ll res=1;
  while(n>0){
    if(n&1)res=res*a%mod;
    a=a*a%mod;
    n>>=1;
  }
  return res;
}
int main(void){
  int a[4];
  FOR(i,4)INI(a[i]);
  char s[2][4]={"Yes","No"};
  PRS(s[a[0]/a[3]<a[2]/a[1]]);
  return 0;
}
//  [c]
#include <stdio.h>

struct st_pokemon //モンスターのステータス用構造体(体力・攻撃力)
{
	int hp;
	int attack;
};

void main(void)
{
	struct st_pokemon takahashi;
	struct st_pokemon aoki;
	int hp_judge	        = 0;
	int attack_judge 		= 0;
    int result				= 0;

	scanf( "%d %d %d %d", &takahashi.hp , &takahashi.attack , &aoki.hp , &aoki.attack );
	
	hp_judge            = takahashi.hp - aoki.hp;
  	attack_judge		= takahashi.attack - aoki.attack;
  
    result				= attack_judge / hp_judge ;

	if( result >= 0 )
	{
		printf("Yes");
	}
	else
	{
		printf("No");
	}
 
 	return;
}
//  [c]
#include <stdio.h>

int takahashi_attack(int hp, int at)
{
    int remain_hp;
    remain_hp = hp - at;
    return remain_hp;
}

int aoki_attack(int hp, int at)
{
    int remain_hp;
    remain_hp = hp - at;
    return remain_hp;
}

int main(void)
{
    int A, B, C, D;
    int aoki_remain;
    int takahashi_remain;

    scanf("%d %d %d %d", &A, &B, &C, &D);
    while (1)
    {
        aoki_remain = takahashi_attack(C, B);
        C = aoki_remain;
        printf("aoki_remain:%d\n", aoki_remain);
        if (aoki_remain == 0)
        {
            printf("Yes\n");
            break;
        }
        takahashi_remain = aoki_attack(A, D);
        A = takahashi_remain;
        printf("takahashi_remain:%d\n", takahashi_remain);
        if (takahashi_remain == 0)
        {
            printf("No\n");
            break;
        }
    }
    return 0;
}
//  [javascript]
function Main(input) {
	input = input.split(" ");
	var tHP = parseInt(input[0], 10);
	var tAT = parseInt(input[1], 10);
	var aHP = parseInt(input[2], 10);
	var aAT = parseInt(input[3], 10);


var a =  Math.ceil(aHP  /  tAT )

var t =  Math.ceil(tHP  /  aAT )

if (t >= a){
	console.log('Yes');
}else{
	console.log('No');

}


}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
const Main = input => {
  const sp = input.split(' ').map(e => Number(e));

  const a = Math.ceil( sp[2] / sp[1] );
  const b = Math.ceil( sp[0] / sp[3] );

  const resultA = sp[0] - sp[3]*b;
  const resultB = sp[2] - sp[1]*a;

  console.log(a <= b ? 'Yes' : 'No');
};

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//Main(`10 9 10 10`);
//Main(`45 4 39 5`)
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
	var ans
	// 1行目がinput[0], 2行目がinput[1], …に入る
	input = input.trim().split("\n");
	s = input[0].split(' ').map((n) => (parseInt(n)))
	while (true) {
		s[2] = s[2] - s[1]
		if (s[2] <= 0 ) {
			ans = 'Yes'
			break;
		}
		s[0] = s[0] - s[3]
		if (s[0] <= 0 ) {
			ans = 'No'
			break;
		}
	}

	//出力
	console.log(ans)
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
// Main(require('fs').readFileSync('./input.txt', 'utf-8'));
//  [javascript]
import java.util.*;
 public class Main {
	public static void main(String[] args){
      int A = 100;
      int B = 10;
      int C = 100;
      int D = 9;

      float E = A / D;
      float F = C / B;

      if(E > F){
         System.out.println("Yes");
      }else{
         System.out.println("No");
      }
   }
 }
//  [javascript]
function Main(input) {
	var str = input;
	str = str.split("\n")[0];
    str = str.split(' ');
    var thp = Number(str[0]);
    var tpw = Number(str[1]);
    var ahp = Number(str[2]);
    var apw = Number(str[3]);
    while(thp > 0 && ahp > 0 ){
   		ahp = ahp - tpw;
   		if(ahp <=0){
   			console.log("Yes");
   			break;
   		}
   		thp = thp - tpw;
   		if(thp <=0){
   			console.log("No");
   			break;
   		}
    }
}
 //*おまじない
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	var str = input;
	str = str.split("\n")[0];
    str = str.split(' ');
    console.log(str);
    var thp = Number(str[0]);
    var tpw = Number(str[1]);
    var ahp = Number(str[2]);
    var apw = Number(str[3]);
    while(thp > 0 && ahp > 0 ){
   		ahp = ahp - tpw;
   		if(ahp <=0){
   			console.log("Yes");
   			break;
   		}
   		thp = thp - tpw;
   		if(thp <=0){
   			console.log("No");
   			break;
   		}
    }
}
 //*おまじない
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import(
	"fmt"
)

var a, b, c, d int

func main() {
	fmt.Scan(&a, &b, &c, &d)

	for true {
		c -= b
		if c <= 0 {
			fmt.Println("Yes");
			return
		}
		a -= d
		if a <= 0 {
			fmt.Println("No");
			return
		}
	}
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

const initBufSize, maxBufSize = 10000, 1000000

func nextStr() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func nextInts(n int) []int {
	res := make([]int, n)
	for i := range res {
		res[i] = nextInt()
	}
	return res
}

func min(nums ...int) int {
	if len(nums) == 0 {
		panic("funciton min() requires at least one argument.")
	}
	res := nums[0]
	for i := 0; i < len(nums); i++ {
		res = int(math.Min(float64(res), float64(nums[i])))
	}
	return res
}

func max(nums ...int) int {
	if len(nums) == 0 {
		panic("funciton max() requires at least one argument.")
	}
	res := nums[0]
	for i := 0; i < len(nums); i++ {
		res = int(math.Max(float64(res), float64(nums[i])))
	}
	return res
}

func abs(n int) int {
	return int(math.Abs(float64(n)))
}

func pow(r, n int) int {
	return int(math.Pow(float64(r), float64(n)))
}

func attackCount(hp, at int) int {
	count := math.Ceil(float64(hp) / float64(at))
	return int(count)
}

func main() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, initBufSize), maxBufSize)
	hpTakahashi := nextInt()
	atTakahashi := nextInt()
	hpAoki := nextInt()
	atAoki := nextInt()

	//相手を倒すまでの攻撃回数
	countTakahashi := attackCount(hpAoki, atTakahashi)
	countAoki := attackCount(hpTakahashi, atAoki)

	if countTakahashi <= countAoki {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	In := ReadLineInt()
	TakahashiHP, TakahashiAttack := In[0], In[1]
	AokiHP, AokiAttack := In[2], In[3]

	for {
		AokiHP -= TakahashiAttack

		if AokiHP <= 0 {
			fmt.Println("Yes")
			return
		}

		TakahashiHP -= AokiAttack

		if TakahashiHP <= 0 {
			fmt.Println("No")
			return
		}
	}
}

/////////////////////////////////////////

func fln(format string, elements ...interface{}) {
	fmt.Printf(format+"\n", elements...)
}

var BufReader = bufio.NewReaderSize(os.Stdin, 1e6)

func ReadLine() string {
	a, _, _ := BufReader.ReadLine()
	return string(a)
}

func ReadLineInt() (result []int) {
	in := strings.Split(ReadLine(), " ")
	result = make([]int, 0, 2)
	for _, v := range in {
		t, _ := strconv.Atoi(v)
		result = append(result, t)
	}
	return
}
//  [go]
package main

import "fmt"

func main() {
	var a, b, c, d int
	fmt.Scan(&a, &b, &c, &d)
	if (a+d-1)/d <= (c+b-1)/b {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main
 
import "fmt"
 
var a, b, c, d int
func main() {
	fmt.Scan(&a)
	fmt.Scan(&b)
	fmt.Scan(&c)
	fmt.Scan(&d)
	if a / d < c / b {
		fmt.Println("No")
	} else {
		fmt.Println("Yes")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var taka_hp, taka_atc, aoki_hp, aoki_atc int
	fmt.Scan(&taka_hp, &taka_atc, &aoki_hp, &aoki_atc)

	aoki_win_count := (taka_hp+aoki_atc-1) / aoki_hp
	taka_win_count := (aoki_hp+taka_atc-1) / taka_atc
	if aoki_win_count >= taka_win_count{
		fmt.Println("Yes")
	}else{
		fmt.Println("No")
	}

}
//  [ruby]
input = gets.split.map(&:to_i)
takahashi_hp = input[0]
takahashi_atk = input[1]
aoki_hp = input[2]
aoki_atk = input[3]

is_takahashi_next = true

while(takahashi_hp > 0 && aoki_hp > 0) do
  if is_takahashi_next
    is_takahashi_next = !is_takahashi_next
    aoki_hp -= takahashi_atk
    next
  else
    is_takahashi_next = !is_takahashi_next
    takahashi_hp -= aoki_atk
    next
  end
end

puts takahashi_hp <= 0 ? 'No' : 'Yes'
//  [ruby]
a, b, c, d = gets.split.map(&:to_i)
while a > 0 || c > 0 do
  c -= b
  break if c <= 0
  a -= d
  break if a <= 0
end
puts c <= 0 ? "Yes" : "No"
//  [ruby]
def count(hp,bp)
  if(hp%bp!=0)
    return hp/bp+1
  end
  return hp/bp
end

A,B,C,D = gets.split()
if(count(A.to_i(),D.to_i())>=count(C.to_i(),B.to_i()))
  puts('Yes')
else
  puts('No')
end
//  [ruby]
a,b,c,d=gets.split.map(&:to_i)
loop do
  c-=a
  break if c<=0
  a-=d
  break if a<=0
end
puts c<=0?'Yes':'No'
//  [ruby]
a,b,c,d=gets.split.map(&:to_i)
loop do
  c-=a
  break if c<0
  a-=d
  break if a<0
end
puts c<0?'Yes':'No'
//  [ruby]
a, b, c, d = gets.split.map(&:to_i)

takahashi_turn = (c%b == 0 ? c/b : c/b + 1)
aoki_turn = (a%d == 0? a/d : a/d + 1)

if takahashi_turn >= aoki_turn
  puts "Yes"
else
  puts "No"
end
//  [rust]
use std::io::Read;

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();

    let answer = solve(&buf);

    println!("{}", answer);
}

fn solve(input: &str) -> String {
    let mut iterator = input.split_whitespace();

    let a: isize = iterator.next().unwrap().parse().unwrap();
    let b: isize = iterator.next().unwrap().parse().unwrap();
    let c: isize = iterator.next().unwrap().parse().unwrap();
    let d: isize = iterator.next().unwrap().parse().unwrap();

    let t1 = (c + b - 1) / b;
    let t2 = (a + d - 1) / d;

    return if t1 <= t2 {
        "Yes".to_string()
    } else {
        "No".to_string()
    }
}
//  [rust]
#![allow(unused_imports)]
#![allow(unused_macros)]
#![allow(non_snake_case)]
#![allow(dead_code)]
#![allow(unused_variables)]
#![allow(unused_mut)]
#![allow(unused_assignments)]
use proconio::input;
use proconio::marker::Usize1;
use std::collections::*;
use std::cmp::*;
use std::f64::consts::*;

const MOD: u64 = 1000000007;
const INF: usize = std::usize::MAX / 4;

fn main() {
    input! {
        mut A: i64,
        mut B: i64,
        mut C: i64,
        mut D: i64,
    }

    for i in 0..1000 {
        if i % 2 == 0 {
            C -= B;
            if C <= 0 {
                println!("Yes");
                break;
            }
        } else {
            A -= D;
            if A <= 0 {
                println!("No");
                break;
            }
        }
    }
}
//  [rust]
use proconio::{input, fastout};

#[fastout]
fn main() {
  input! {
    mut a: isize,
    b: isize,
    mut c: isize,
    d: isize,
  }
  
  let mut turn: isize = 0;
  while (a > 0) & (c > 0) {
    if turn % 2 == 0 {
      c -= b;
    }
    else {
      a -= d;
    }
    turn += 1;
  }
  
  let ans = if c <= 0 {"Yes"} else {"No"};
  println!("{}", ans);
}
//  [rust]
#[allow(unused_imports)]
use proconio::{fastout, input, marker::*};

#[fastout]
fn main() {
    input! {
        a: usize,
        b: usize,
        c: usize,
        d: usize,
    }

    let x = c / b + c % b;
    let y = a / d + a % d;

    if x <= y {
        println!("Yes");
    } else {
        println!("No");
    }
}
//  [rust]
use proconio::{input, fastout};

#[fastout]
fn main() {
    input! {
        mut a: i64,
        b: i64,
        mut c: i64,
        d: i64,
    }

    while a > 0 && c > 0 {
        c -= b;
        a -= d;
    }

    if a <= 0 && c <= 0 {
        println!("Yes");
    } else if a <= 0 {
        println!("No")
    } else {
        println!("No")
    }
}
//  [rust]
use proconio::{input, fastout};

#[fastout]
fn main() {
    input! {
        mut a: i64,
        b: i64,
        mut c: i64,
        d: i64,
    }

    while a > 0 && c > 0 {
        a -= d;
        c -= b
    }

    if a <= 0 && c <= 0 {
        println!("Yes");
    } else if a <= 0 {
        println!("No")
    } else {
        println!("No")
    }
}
//  [swift]
let abcd = readLine()!.split(separator: " ").map { Int($0)! }
let (a, b, c, d) = (abcd[0], abcd[1], abcd[2], abcd[3])

var v0 = c / b
if c % b != 0 { v0 += 1 }
var v1 = a / d
if a % d != 0 { v1 += 1 }

if v0 <= v1 {
  print("Yes")
} else {
  print("No")
}
//  [swift]
let line = readLine()!
let abcd = line.split(separator: " ").map { Int($0)! }
var a = abcd[0]; var b = abcd[1]; var c = abcd[2]; var d = abcd[3]

while true { 
  c -= b
  if c <= 0 {
    print("Yes")
    break
  }
  a -= d
  if a <= 0 {
    print("No")
    break
  }
}
//  [swift]
let inputs = readLine()!.split(separator: " ").map { Int($0)! }
var (A, B, C, D) = (inputs[0], inputs[1], inputs[2], inputs[3])

while true {
    C -= B
    if C <= 0 {
        break
    }
    
    A -= D
    if A <= 0 {
        break
    }
}

print(A <= 0 ? "No" : "Yes")
//  [swift]
import Foundation
let input = readLine()!.split(separator: " ").map({ Int($0)! })
print(input[0]-input[3]>input[2]-input[1] ? "Yes":"No")
//  [swift]
let abcd = readLine()!.split(separator: " ").map { Int($0)! }
let (a, b, c, d) = (abcd[0], abcd[1], abcd[2], abcd[3])

if (Double(c) / Double(b)).rounded(.up) <= (Double(a) / Double(d)).rounded(.up) {
  print("Yes")
} else {
  print("No")
}
//  [swift]
let num = readLine()!.split(separator: " ").compactMap{Int($0)}
    
    let a = num[3] - num[1]
    
    let b = num[0] - num[2]
    
    if a > b {
      print("No")
    } else {
      print("Yes")
    }
//  [typescript]
import * as fs from 'fs';

namespace AtCoder.abc001 {

    export class Program {

        constructor(private readonly args: string[][]) {
        }

        /**
         * in
         *
         * out
         *
         */
        main(this: Program): void {
            let [a, b, c, d]: number[] = this.args[0].map(Number);


            while (a > 0 || c > 0) {

                c -= b;
                if (c <= 0) {
                    console.log('Yes');
                    break;
                }

                a -= d;

                if (a <= 0) {
                    console.log('No');
                    break;
                }


            }


        }
    }
}

const args: string[][] = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n').map(r => r.split(' '));
const prg: AtCoder.abc001.Program = new AtCoder.abc001.Program(args);
prg.main();