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.

Difficulty: interview

Starter code:

Solutions:
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()))

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)


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)
    


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)

#!/usr/bin/env python3

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 = 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)


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)


sections,nuts,divisors,cap = list(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)


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)

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)

def __starting_point(): main()

__starting_point()

k, a, b, v = list(map(int, input().split()))

#k, a, b, v = 3, 10, 1, 3
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())
ans=0
while a>0:
    ans+=1
    kn=min(k,b+1)
    a-=v*kn
    b=max(b-k+1,0)
print(ans)

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)


max_parts, n, divisors, nuts_in_part = map(int, input().split())
L = 0
R = 10000
while R - L > 1:
    #print(L, R)
    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)

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


import sys

f = sys.stdin
# f = open("input.txt", "r")

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)

k, a, b, v = list(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)


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


def ceiling_div(x, y):
	res = x // y
	if (x % y != 0):
		res += 1
	return res
	
k, a, b, v = list(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()))
outcome = 0
while a > 0:
    outcome += 1
    kn = min(k, b+1)
    a -= kn * v
    b = max(0, b - kn + 1)
print(outcome)



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")


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
#print(ts)
tb += a[2] // (a[0] - 1)
ts -= tb * a[0]
a[2] -= tb * (a[0] - 1)
#print(ts)
if (ts <= 0):
    ts += tb * a[0]
    #print(ts)
    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))
 


#-------------------------------------------------------------------------------
# Name:        module1
# Purpose:
#
# Author:      mayank manish
#
# Created:
# Copyright:   (c) mayank manish
# Licence:     <your licence>
#-------------------------------------------------------------------------------

def main():
    pass

def __starting_point():
    main()
k,a,b,v=list(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)

__starting_point()

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(nuts)
print(boxes)


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)