You have a nuts and lots of boxes. The boxes have a wonderful feature: if you put x (x ≥ 0) divisors (the spacial bars that can divide a box) to it, you get a box, divided into x + 1 sections.

You are minimalist. Therefore, on the one hand, you are against dividing some box into more than k sections. On the other hand, you are against putting more than v nuts into some section of the box. What is the minimum number of boxes you have to use if you want to put all the nuts in boxes, and you have b divisors?

Please note that you need to minimize the number of used boxes, not sections. You do not have to minimize the number of used divisors.


-----Input-----

The first line contains four space-separated integers k, a, b, v (2 ≤ k ≤ 1000; 1 ≤ a, b, v ≤ 1000) — the maximum number of sections in the box, the number of nuts, the number of divisors and the capacity of each section of the box.


-----Output-----

Print a single integer — the answer to the problem.


-----Examples-----
Input
3 10 3 3

Output
2

Input
3 10 1 3

Output
3

Input
100 100 1 1000

Output
1



-----Note-----

In the first sample you can act like this:   Put two divisors to the first box. Now the first box has three sections and we can put three nuts into each section. Overall, the first box will have nine nuts.  Do not put any divisors into the second box. Thus, the second box has one section for the last nut. 

In the end we've put all the ten nuts into boxes.

The second sample is different as we have exactly one divisor and we put it to the first box. The next two boxes will have one section each.

Source: codeforces | Difficulty: EASY
Tags: Mathematics

Greedy algorithms


Solutions:
(k, a, b, v) = map(int, input().split())
answ = 0
while a != 0 and b != 0:
	a -= min(v * min(k, b + 1), a)
	b -= min(k - 1, b)
	answ += 1
answ += a // v + int(a % v != 0)
print(answ)


str_ = input()
items = str_.strip().split()
k = int(items[0])
a = int(items[1])
b = int(items[2])
v = int(items[3])
sum_ = 0
ans = 0
while sum_ < a:
	if b != 0:
		sum_ += min(k, b + 1) * v
		b = max(0, b - k + 1)
	else:
		sum_ += v
	ans += 1
print(str(ans) + '\n')


import math
from collections import Counter
(max_sec, a, divNum, capa, whole, sec, boxes, hap) = (0, 0, 0, 0, input(), int(0), int(0), True)
who = whole.split(' ')
(max_sec, a, divNum, capa) = (int(who[0]), int(who[1]), int(who[2]), int(who[3]))
while a > 0:
	if a <= capa:
		boxes += 1
		a -= a
		break
	if max_sec * capa < a and max_sec <= divNum and (sec != max_sec):
		a -= capa * max_sec
		sec += max_sec
		divNum -= max_sec - 1
	elif sec != max_sec:
		while divNum != 0 and sec != max_sec:
			a -= capa
			divNum -= 1
			sec += 1
	if divNum == 0:
		a -= capa
		boxes += 1
	if sec == max_sec:
		boxes += 1
		sec = 0
print(boxes)


def main():
	pass
main()
(k, a, b, v) = map(int, input().split())
n = 0
if b < k:
	a -= (b + 1) * v
	n += 1
	while a > 0:
		a -= v
		n += 1
	print(n)
else:
	while b >= k and a > 0:
		b -= k - 1
		a -= k * v
		n += 1
	if a > 0:
		a -= (b + 1) * v
		n += 1
		while a > 0:
			a -= v
			n += 1
	print(n)


def ceiling_div(x, y):
	res = x // y
	if x % y != 0:
		res += 1
	return res
(k, a, b, v) = map(int, input().split())
sec = ceiling_div(a, v)
res = max(sec - b, ceiling_div(sec, k))
print(res)


(k, a, b, v) = list(map(int, input().split()))
usedNuts = 0
boxes = 0
while usedNuts < a:
	boxes += 1
	div = min(k, b + 1)
	usedNuts += div * v
	b -= div - 1
print(boxes)


(k, a, b, v) = map(int, input().split(' '))
(c, i) = (1, 1)
while a - v > 0:
	a -= v
	if i < k and b > 0:
		i += 1
		b -= 1
	else:
		i = 1
		c += 1
print(c)


from math import ceil
(k, a, b, v) = map(int, input().split())
x = b // (k - 1)
ost = b % (k - 1)
n = v * k
if x * n >= a:
	print(ceil(a / (k * v)))
else:
	d = x
	a -= x * n
	if (ost + 1) * v >= a:
		print(d + 1)
	else:
		d += 1
		a -= (ost + 1) * v
		print(d + ceil(a / v))


from math import ceil
(k, a, b, v) = list(map(int, input().split()))
res = 0
c = ceil(a / v)
while b >= k - 1 and c > 0:
	res += 1
	c -= k
	b -= k - 1
if c > 0:
	res += 1
	c -= b + 1
if c > 0:
	res += c
print(res)


(k, a, b, v) = list(map(int, input().split()))
t = (a + v - 1) // v
for x in range(1, t + 1):
	if 0 <= t - x <= b and x <= t <= k * x:
		print(x)
		break


from math import ceil
(k, a, b, v) = list(map(int, input().split(' ')))
p = ceil(a / v)
cajas = 0
dcaja = k - 1
divs = b
for i in range(p):
	if dcaja == k - 1 or divs == 0:
		cajas += 1
		dcaja = 0
	else:
		dcaja += 1
		divs -= 1
print(cajas)


(a, b, c, d) = map(int, input().split())
if d > b:
	d = b
k = b // d
if b % d > 0:
	k += 1
i = 0
while k > 0:
	if a > c + 1:
		a = c + 1
	if k >= a:
		i += 1
		k -= a
		c -= a - 1
	elif k == 1:
		i += 1
		k -= 1
	else:
		i += 1
		k = 0
	if c == 0:
		i += k
		break
print(i)


(k, a, b, v) = map(int, input().split())
result = 1
x = 1
while a > 0:
	if b > 0:
		if x < k:
			b -= 1
			x += 1
			a -= v
		else:
			a -= v
			if a > 0:
				result += 1
				x = 1
	else:
		a -= v
		if a > 0:
			result += 1
print(result)


(k, a, b, v) = list(map(int, input().split()))
count = 0
while True:
	if b >= k - 1:
		b -= k - 1
		a -= v * k
		count += 1
	else:
		a -= v * (b + 1)
		b = 0
		count += 1
	if a <= 0:
		print(count)
		break


import math

def main():
	n = input().split()
	k = int(n[0])
	a = int(n[1])
	b = int(n[2])
	v = int(n[3])
	if k > b + 1:
		print(1 + max(math.ceil((a - (b + 1) * v) / v), 0))
		return 0
	maxboxes = math.floor(b / (k - 1))
	if maxboxes * k * v > a:
		print(math.ceil(a / (k * v)))
		return 0
	a = a - maxboxes * k * v
	b = b - maxboxes * (k - 1)
	a = a - (b + 1) * v
	print(maxboxes + 1 + max(math.ceil(a / v), 0))
	return 0
main()


(k, a, b, v) = map(int, input().split())
outcome = 0
while a > 0:
	outcome += 1
	kn = min(k, b + 1)
	a -= kn * v
	b = max(0, b - kn + 1)
print(outcome)


(sections, nuts, divisors, cap) = map(int, input().split())
boxes = 0
while nuts > 0:
	s = 1
	if divisors > 0 and divisors <= sections - 1:
		s = divisors + 1
		divisors = 0
	elif divisors > sections - 1:
		s = sections
		divisors -= sections - 1
	nuts -= s * cap
	boxes += 1
print(boxes)


x = input()
(max_sections, nuts, divisors, max_nuts) = [int(i) for i in x.split()]
divisors_per = max_sections - 1
fit = max_sections * max_nuts
boxes = 1
while 1:
	if divisors_per > divisors:
		sections = divisors + 1
		nuts -= sections * max_nuts
		divisors = 0
	else:
		nuts -= fit
		divisors -= divisors_per
	if nuts <= 0:
		break
	else:
		boxes += 1
print(boxes)


(k, a, b, v) = map(int, input().split())
cnt = 1
while True:
	if b + 1 - k < 0:
		use_b = b + 1
	else:
		use_b = k
	if use_b != 0:
		max_or = use_b * v
	else:
		max_or = v
	if a - max_or > 0:
		cnt += 1
		b = b + 1 - use_b
		a -= max_or
	else:
		print(cnt)
		break


string = str(input()) + ' '
word = ''
wordlist = []
boxes = 0
for char in string:
	if char != ' ':
		word += char
	else:
		wordlist.append(int(word))
		word = ''
maxsections = wordlist[0]
nuts = wordlist[1]
divisors = wordlist[2]
maxnuts = wordlist[3]
while nuts > 0:
	boxes += 1
	if divisors >= maxsections - 1:
		divisors -= maxsections - 1
		if nuts >= maxsections * maxnuts:
			nuts -= maxsections * maxnuts
		elif nuts < maxsections * maxnuts:
			nuts = 0
	elif divisors < maxsections - 1:
		if nuts >= (divisors + 1) * maxnuts:
			nuts -= (divisors + 1) * maxnuts
		elif nuts < (divisors + 1) * maxnuts:
			nuts = 0
		divisors = 0
print(boxes)


l = [int(i) for i in input().split(' ')]
k = l[0]
a = l[1]
b = l[2]
v = l[3]
box = 0
divs = 0
while a > 0:
	box += 1
	sections = 1
	a -= v
	while a > 0 and sections < k and (divs < b):
		divs += 1
		sections += 1
		a -= v
print(box)


(k, a, b, v) = list(map(int, input().split(' ')))
ans = 1
cur_section_count = 1
while a > 0:
	a -= v
	if a <= 0:
		break
	if cur_section_count < k and b > 0:
		cur_section_count += 1
		b -= 1
	else:
		cur_section_count = 1
		ans += 1
print(ans)


(k, a, b, v) = list(map(int, input().split()))
rezult = 0
box = {'sep': 0, 'place': 0, 'nuts': 0}
while a > 0:
	if b >= 0:
		if b < k:
			box['sep'] = b
			box['place'] = b + 1
			b = 0
		elif b == 0:
			box['sep'] = 0
			box['place'] = 1
		else:
			box['sep'] = k - 1
			box['place'] = k
			b -= box['sep']
	if a < v * box['place']:
		box['nuts'] = a
		a = 0
	else:
		a -= v * box['place']
	rezult += 1
print(rezult)


(k, a, b, v) = map(int, input().split())
for ans in range(10000):
	cnt = ans + min((k - 1) * ans, b)
	if cnt * v >= a:
		print(ans)
		break


(k, a, b, v) = map(int, input().split())
cnt = 0
while a > 0:
	if b >= k - 1:
		b = b - k + 1
		a -= k * v
	elif b:
		a -= (b + 1) * v
		b = 0
	else:
		a -= v
	cnt += 1
print(cnt)


def read_ints():
	return list(map(int, input().strip().split()))
(k, a, b, v) = read_ints()
z = (a + v - 1) // v
used_boxes = 0
free_div = b
last_box_sec = float('inf')
while z:
	if last_box_sec < k and free_div > 0:
		last_box_sec += 1
		free_div -= 1
	else:
		used_boxes += 1
		last_box_sec = 1
	z -= 1
print(used_boxes)


(k, a, b, v) = map(int, input().split())
sections = (a - 1) // v + 1
full_boxes = b // (k - 1)
partial_box_sections = b % (k - 1) + 1
boxes_used = 0
if sections <= full_boxes * k:
	boxes_used += (sections - 1) // k + 1
	sections = 0
else:
	sections -= full_boxes * k
	boxes_used += full_boxes
	if sections <= partial_box_sections:
		sections = 0
		boxes_used += 1
	else:
		sections -= partial_box_sections
		boxes_used += 1
		boxes_used += sections
		sections = 0
print(boxes_used)


(k, a, b, v) = map(int, input().split())
val = 0
while a > 0:
	d = min(b, k - 1)
	a -= (d + 1) * v
	b -= d
	val += 1
print(val)


import sys
import string
from collections import Counter, defaultdict
from math import fsum, sqrt, gcd, ceil, factorial
from operator import add
inf = float('inf')
flush = lambda : sys.stdout.flush
comb = lambda x, y: factorial(x) // factorial(y) // factorial(x - y)
ip = lambda : input()
ii = lambda : int(input())
r = lambda : map(int, input().split())
rr = lambda : list(r())
(k, a, b, v) = r()
k -= 1
ans = 0
while a > 0 and b > 0:
	x = min(b, k)
	a -= (x + 1) * v
	b -= x
	ans += 1
if a > 0:
	ans += (a + v - 1) // v
print(ans)


(k, a, b, v) = map(int, input().split())
ans = 0
while a > 0:
	if b + 1 > k:
		a -= k * v
		b -= k - 1
	else:
		a -= v * (b + 1)
		b = 0
	ans += 1
print(ans)


from sys import stdin
__author__ = 'artyom'

def read_next_line():
	return list(map(int, stdin.readline().strip().split()))

def ceildiv(a, b):
	return -(-a // b)
(k, a, b, v) = read_next_line()
s = ceildiv(a, v)
t = k - 1
d = b // t * k + b % t + 1
print(ceildiv(s, k) if s <= d else s - d + b // t + 1)


import fileinput
import math

def test():
	pass
(k, a, b, v) = map(int, input().split())
num_sections = math.ceil(a / v)
num_boxes = math.ceil(num_sections / k)
if num_sections > b + 1:
	num_boxes = num_sections - b
print(num_boxes)


import math
(k, a, b, v) = map(int, input().split())
if v > a:
	print(1)
elif b + 1 < k:
	a = a - v * (b + 1)
	ans = math.ceil(a / v)
	print(ans + 1)
else:
	c = 1
	a = a - v * k
	b = b - k + 1
	while a > 0 and b > 0:
		if v * (b + 1) > a and b < k:
			c += 1
			a = 0
			break
		else:
			if b > k:
				if v > a:
					c += 1
					a = 0
				else:
					a = a - v * k
					c += 1
					b = b - (k - 1)
			if b <= k:
				a = a - v * (b + 1)
				c += 1
				b = 0
	if b == 0 and a > 0:
		c += math.ceil(a / v)
	print(c)


(k, a, b, v) = [int(x) for x in input().split()]
ans = 0
while a > 0:
	l = min(k - 1, b)
	b -= l
	a -= (l + 1) * v
	ans += 1
print(ans)


(k, a, b, v) = map(int, input().split())
res = 0
while a > 0:
	if b + 1 <= k:
		y = (b + 1) * v
		a -= y
		b = 0
		res += 1
	else:
		b -= k - 1
		y = k * v
		a -= y
		res += 1
print(res)


import math
(k, a, b, v) = map(int, input().split())
ans = 0
while a > 0:
	l = min(k - 1, b)
	b -= l
	a -= (l + 1) * v
	ans += 1
print(ans)


(k, a, b, v) = list(map(int, input().split()))
for i in range(1, 2000):
	t = min(k, b + 1)
	a -= t * v
	b -= t - 1
	if a <= 0:
		print(i)
		break


bot = True
from math import ceil
(k, a, b, v) = [int(i) for i in input().split()]
print(max(ceil(a / v - b), ceil(a / (k * v))))


import math

def main():
	(k, a, b, v) = [int(i) for i in input().split()]
	s = math.ceil(a / v)
	total = min(b // (k - 1), math.ceil(s / k))
	if b // (k - 1) < math.ceil(s / k):
		s -= b // (k - 1) * k
		x = 1 + b % (k - 1)
		total += 1
		if s > x:
			total += s - x
	print(total)
main()


import re
import inspect
from sys import argv, exit
from math import ceil

def rstr():
	return input()

def rstrs(splitchar=' '):
	return [i for i in input().split(splitchar)]

def rint():
	return int(input())

def rints(splitchar=' '):
	return [int(i) for i in rstrs(splitchar)]

def varnames(obj, namespace=globals()):
	return [name for name in namespace if namespace[name] is obj]

def pvar(var, override=False):
	prnt(varnames(var), var)

def prnt(*args, override=False):
	if '-v' in argv or override:
		print(*args)
pq = []

def penq(s):
	if not isinstance(s, str):
		s = str(s)
	pq.append(s)

def pdump():
	s = '\n'.join(pq).encode()
	os.write(1, s)
(sec_per_box, nuts, divs, cap) = rints()
prnt('secs/box:', sec_per_box, 'nuts', nuts, 'divs', divs, 'cap', cap)
total_secs_needed = ceil(nuts / cap)
prnt('total_secs_needed', total_secs_needed)
if total_secs_needed < sec_per_box:
	ans = 1
	if divs < sec_per_box - 1:
		total_secs_needed -= 1 + divs
		if total_secs_needed > 0:
			ans += total_secs_needed
	print(ans)
	exit(0)
fdb = divs // (sec_per_box - 1)
prnt('fdb', fdb)
if fdb * sec_per_box > total_secs_needed:
	prnt('top')
	ans = ceil(total_secs_needed / sec_per_box)
	print(ans)
else:
	prnt('bot')
	nuts -= fdb * sec_per_box * cap
	total_secs_needed -= fdb * sec_per_box
	divs -= fdb * (sec_per_box - 1)
	ans = fdb
	if divs:
		prnt('if divs')
		ans += 1
		nuts -= (divs + 1) * cap
	prnt('nuts, cap: ', nuts, cap)
	if nuts > 0:
		ans += ceil(nuts / cap)
	print(ans)


from sys import stdin, stdout
from collections import Counter

def ai():
	return list(map(int, stdin.readline().split()))

def ei():
	return map(int, stdin.readline().split())

def ip():
	return int(stdin.readline().strip())

def op(ans):
	return stdout.write(str(ans) + '\n')
(k, a, b, v) = ei()
for i in range(1, 2000):
	t = min(k, b + 1)
	a -= t * v
	b -= t - 1
	if a <= 0:
		print(i)
		break


(k, a, b, v) = map(int, input().split())
box = 0
rem = a
while rem > 0:
	box += 1
	comp = 0
	if b > k - 1:
		comp = k
		b -= k - 1
	else:
		comp = b + 1
		b = 0
	rem -= v * comp
print(box)


(max_section, nuts, divisor, capacity) = map(int, input().split())

def lt(x):
	if x - int(x) > 0:
		return int(x) + 1
	return int(x)
max_divisor = max_section - 1
box_max_section = int(divisor / max_divisor)
extra_box_capacity = (divisor % max_divisor + 1) * capacity
if nuts > box_max_section * capacity * max_section:
	rs = box_max_section
	nuts -= box_max_section * max_section * capacity
	if nuts > extra_box_capacity:
		rs += 1 + lt((nuts - extra_box_capacity) / capacity)
	else:
		rs += 1
else:
	rs = lt(nuts / (max_section * capacity))
print(rs)


(k, a, b, v) = map(int, input().split())
o = 0
while a > 0:
	o += 1
	a -= v * min(b + 1, k)
	b -= min(b, k - 1)
print(o)


R = lambda : map(int, input().split())
(k, a, b, v) = R()
a1 = b // (k - 1)
a2 = b % (k - 1)
if a <= v * a1 * k:
	print((a + (v * k - 1)) // (v * k))
elif v * a1 * k < a <= v * a1 * k + (a2 + 1) * v:
	print(a1 + 1)
else:
	print(a1 + 1 + (a - v * a1 * k - (a2 + 1) * v + v - 1) // v)


(k, a, b, v) = map(int, input().split())
r = 0
while b > 0:
	r += 1
	if b > k - 1:
		n = k - 1
	else:
		n = b
	x = (n + 1) * v
	if x >= a:
		a = 0
		break
	a -= x
	b -= n
if a != 0:
	r += a // v
	if a % v != 0:
		r += 1
print(r)


def f(l):
	(k, a, b, v) = l
	ns = (a + v - 1) // v
	return max(ns - b, (ns + k - 1) // k)
l = list(map(int, input().split()))
print(f(l))


(k, a, b, v) = map(int, input().split())
for i in range(1, 1010):
	if a <= v * (i + min(b, (k - 1) * i)):
		print(i)
		break


(k, a, b, v) = list(map(int, input().split()))
x = 0
while a > 0:
	c = 1
	if b > k - 1:
		c += k - 1
		b -= k - 1
	else:
		c += b
		b = 0
	a -= v * c
	x += 1
print(str(x))


(k, a, b, v) = map(int, input().split())
c = 0
while True:
	a -= v
	if b > 0:
		if k - 1 > b:
			a -= b * v
			b = 0
		else:
			b -= k - 1
			a -= (k - 1) * v
	c += 1
	if a <= 0:
		print(c)
		break


(max_parts, n, divisors, nuts_in_part) = map(int, input().split())
L = 0
R = 10000
while R - L > 1:
	M = (L + R) // 2
	available_divisors = min(M * (max_parts - 1), divisors)
	if (M + available_divisors) * nuts_in_part >= n:
		R = M
	else:
		L = M
available_divisors = min(L * (max_parts - 1), divisors)
if (L + available_divisors) * nuts_in_part >= n:
	print(L)
else:
	print(R)


(sections, nuts, divisors, capacity) = map(int, input().split())
count = 0
while True:
	if nuts <= 0:
		print(count)
		break
	else:
		x = min(sections - 1, divisors)
		divisors -= x
		nuts -= (x + 1) * capacity
		count += 1


(k, a, b, v) = map(int, input().split())
print((a - 1) // v + 1 - b if v * (b + 1 + b // (k - 1)) < a else (a - 1) // (v * k) + 1)


(k, a, b, v) = map(int, input().split())
c = b // (k - 1)
t = c * k * v + (b - c * (k - 1) + 1) * v
if t < a:
	print(c + 2 + (a - t - 1) // v)
else:
	print((a - 1) // (k * v) + 1)


(k, a, b, v) = map(int, input().split())
ans = 0
while a > 0 and b > 0:
	ans += 1
	n = min(k, b + 1)
	a = a - n * v
	b = b - (n - 1)
while a > 0:
	ans += 1
	a -= v
print(ans)


(otseki, nuts, raz, vmest) = list(map(int, input().split()))
maxbox = vmest * otseki
boxes = 0
curbox = vmest
while nuts > 0:
	if curbox < maxbox and raz > 0:
		curbox += vmest
		raz -= 1
	else:
		nuts -= curbox
		curbox = vmest
		boxes += 1
print(boxes)


(k, a, b, v) = map(int, input().split())
l = []
while b > 0:
	if b >= k:
		b1 = k - 1
		l.append((b1 + 1) * v)
		b = b - b1
	else:
		l.append((b + 1) * v)
		b = 0
tb = 0
s = 0
for i in range(len(l)):
	a = a - l[i]
	tb = tb + 1
	if a <= 0:
		break
if a > 0:
	while a > 0:
		a = a - v
		tb = tb + 1
print(tb)


import sys
f = sys.stdin
(k, a, b, v) = map(int, f.readline().split())
cnt = 0
boxes = 0
while cnt < a:
	if k - 1 <= b:
		cnt += k * v
		b -= k - 1
	elif b > 0:
		cnt += (b + 1) * v
		b = 0
	else:
		cnt += v
	boxes += 1
print(boxes)


def main():
	(k, a, b, v) = map(int, input().split())
	res = (b + k - 2) // (k - 1)
	o = b + res
	if o * v < a:
		res += (a + v - 1) // v - o
	else:
		res = (a + k * v - 1) // (k * v)
	print(res)
main()


(sections, a, divisors, cap) = map(int, input().split())
count = 0
while a != 0:
	k = min(sections, divisors + 1)
	divisors = divisors - k + 1
	if a <= k * cap and k != 0:
		count += 1
		break
	elif a > k * cap and k != 0:
		a -= k * cap
		count += 1
	else:
		count += a // cap + min(1, a % cap)
		break
print(count)


(mxd, n, d, ns) = map(int, input().split(' '))
res = 0
while n > 0:
	for i in range(mxd, -1, -1):
		if i <= d and i < mxd:
			res += 1
			n -= ns * (i + 1)
			if d > 0:
				d -= i
			break
print(res)


from math import ceil
(k, a, b, v) = list(map(int, input().split()))
Box = 0
while a:
	Section = min(b, k - 1) + 1
	b -= Section - 1
	Total = min(v, ceil(a / Section))
	a -= min(a, Total * Section)
	Box += 1
print(Box)


from math import ceil
(Div_, Nuts_, Sec_, Nut_Cap_) = map(int, input().split())
Boxes_ = Sec_ // (Div_ - 1)
Remaining_ = Sec_ % (Div_ - 1)
if Remaining_:
	Total_capcaity = Boxes_ * Div_ * Nut_Cap_ + (Remaining_ + 1) * Nut_Cap_
else:
	Total_capcaity = Boxes_ * Div_ * Nut_Cap_
if Nuts_ >= Total_capcaity:
	Nuts_ = Nuts_ - Total_capcaity
	if Remaining_:
		ans = Boxes_ + 1
	else:
		ans = Boxes_
	ans = ans + ceil(Nuts_ / Nut_Cap_)
elif Nuts_ > Boxes_ * Div_ * Nut_Cap_:
	ans = Boxes_ + 1
else:
	ans = ceil(Nuts_ / (Div_ * Nut_Cap_))
print(ans)


(sec, nut, div, cap) = map(int, input().split())
mb = nut // cap
if nut % cap > 0:
	mb += 1
rb = mb // sec
if mb % sec > 0:
	rb += 1
print(max(rb, mb - div))


(k, a, b, v) = map(int, input().split())
ans = 0
while a > 0:
	y = min(k - 1, b)
	b -= y
	a -= (y + 1) * v
	ans += 1
print(ans)


import math
boxes = 0
(k, a, b, v) = map(int, input().split())
if k > b + 1:
	k = b + 1
numfb = b // (k - 1)
extrak = b % (k - 1)
while a > 0 and numfb > 0:
	boxes += 1
	numfb -= 1
	a -= k * v
if extrak > 0 and a > 0:
	boxes += 1
	a -= (extrak + 1) * v
while a > 0:
	boxes += 1
	a -= v
print(boxes)


def floor(x):
	if x == int(x):
		return int(x)
	else:
		return int(x) + 1
a = input()
a = list(a.split(' '))
a = list(map(int, a))
ts = floor(a[1] / a[3])
tb = 0
tb += a[2] // (a[0] - 1)
ts -= tb * a[0]
a[2] -= tb * (a[0] - 1)
if ts <= 0:
	ts += tb * a[0]
	print(floor(a[1] / (a[0] * a[3])))
else:
	tb += 1
	ts -= a[2] + 1
	if ts <= 0:
		print(int(tb))
	else:
		tb += ts
		print(int(tb))