problem

Chairman K is a regular customer of the JOI pizza shop in the center of JOI city. For some reason, he decided to start a life-saving life this month. So he wanted to order the pizza with the highest calories per dollar among the pizzas he could order at the JOI pizza store. Let's call such a pizza the "best pizza". The "best pizza" is not limited to one type.

At JOI Pizza, you can freely choose from N types of toppings and order the ones placed on the basic dough. You cannot put more than one topping of the same type. You can also order a pizza that doesn't have any toppings on the dough. The price of the dough is $ A and the price of the toppings is $ B. The price of pizza is the sum of the price of the dough and the price of the toppings. That is, the price of a pizza with k types of toppings (0 ≤ k ≤ N) is A + k x B dollars. The total calorie of the pizza is the sum of the calories of the dough and the calories of the toppings placed.

Create a program to find the number of calories per dollar for the "best pizza" given the price of the dough and the price of the toppings, and the calorie value of the dough and each topping.

input

The input consists of N + 3 lines.

On the first line, one integer N (1 ≤ N ≤ 100) representing the number of topping types is written. On the second line, two integers A and B (1 ≤ A ≤ 1000, 1 ≤ B ≤ 1000) are written with a blank as a delimiter. A is the price of the dough and B is the price of the toppings. On the third line, one integer C (1 ≤ C ≤ 10000) representing the number of calories in the dough is written.

On the 3 + i line (1 ≤ i ≤ N), one integer Di (1 ≤ Di ≤ 10000) representing the number of calories in the i-th topping is written.

output

Print the number of calories per dollar for the "best pizza" in one line. However, round down the numbers after the decimal point and output as an integer value.

Input / output example

Input example 1


3
12 2
200
50
300
100


Output example 1


37


In I / O Example 1, with the second and third toppings, 200 + 300 + 100 = 600 calories gives a pizza of $ 12 + 2 x 2 = $ 16.
This pizza has 600/16 = 37.5 calories per dollar. Since this is the "best pizza", we output 37, rounded down to the nearest whole number of 37.5.

Input example 2


Four
20 3
900
300
100
400
1300


Output example 2


100


The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.





Example

Input

3
12 2
200
50
300
100


Output

37

Difficulty: UNKNOWN_DIFFICULTY

Starter code:

Solutions:
N = int(input())
(A, B) = map(int, input().split())
C = int(input())
T = [int(input()) for i in range(N)]
T.sort(reverse=True)
cal = C
cost = A
for t in T:
	if cal / cost < (cal + t) / (cost + B):
		cal += t
		cost += B
	else:
		break
print(cal // cost)


n = int(input())
(a, b) = map(int, input().split())
c = int(input())
(ans, p) = (c / a, a)
d = [int(input()) for i in range(n)]
d.sort(reverse=True)
for i in range(n):
	t = (c + d[i]) / (p + b)
	if t > ans:
		ans = t
		c += d[i]
		p += b
	else:
		break
print(int(ans))


n = int(input())
(c, b) = map(int, input().split())
k = int(input())
A = [int(input()) for _ in range(n)]
A.sort(reverse=True)
r = k / c
for i in A:
	k += i
	c += b
	if k / c <= r:
		break
	else:
		r = k / c
print(int(r))


n = int(input())
(a, b) = map(int, input().split())
c = int(input())
d = sorted([int(input()) for _ in [0] * n], reverse=True)
for i in d:
	if c / a < (c + i) / (a + b):
		c += i
		a += b
	else:
		break
print(c // a)


import sys
from sys import stdin
input = stdin.readline
from collections import namedtuple
item = namedtuple('item', ['cal', 'pri'])

def Cond(x, n, items, pizza):
	y = [items[i].cal - x * items[i].pri for i in range(n)]
	y.sort(reverse=True)
	total = pizza.cal - x * pizza.pri
	for c in y:
		if c > 0:
			total += c
		else:
			break
	return total >= 0

def main(args):
	N = int(input())
	(A, B) = map(int, input().split())
	C = int(input())
	toppings = []
	for i in range(N):
		toppings.append(item(int(input()), B))
	pizza = item(C, A)
	lb = 0
	ub = 100000.0
	for i in range(100):
		mid = (lb + ub) / 2
		if Cond(mid, N, toppings, pizza):
			lb = mid
		else:
			ub = mid
	print(int(ub))
main(sys.argv[1:])


n = int(input())
(a, b) = map(int, input().split())
c = int(input())
topping = []
for _ in range(n):
	d = int(input())
	topping.append(d)
topping.sort(reverse=True)
ans = c // a
total = c
for (i, t) in enumerate(topping):
	total += t
	cal = total // (a + (i + 1) * b)
	if ans <= cal:
		ans = cal
	else:
		break
print(ans)


n = int(input())
(a, b) = map(int, input().split())
c = int(input())
A = a
C = c
top = []
for i in range(n):
	top.append(int(input()))
top.sort(reverse=True)
ans = C / A
for i in top:
	C += i
	A += b
	now = C / A
	if ans < now:
		ans = now
	elif ans >= now:
		break
print(int(ans))


N = int(input())
(A, B) = map(int, input().split())
C = int(input())
D = sorted((int(input()) for _ in [0] * N))[::-1]
E = C // A
for x in D:
	A += B
	C += x
	E = max(E, C // A)
print(E)


N = int(input())
(A, B) = map(int, input().split())
C = int(input())
D = sorted((int(input()) for _ in [0] * N))[::-1]
print(max(((C + sum(D[:i])) // (A + i * B) for i in range(N))))


from itertools import accumulate
num = int(input())
(a, b) = [int(x) for x in input().split()]
p = int(input())
T = []
C = []
for _ in range(num):
	T.append(int(input()))
C.append(int(p / a))
T.sort(reverse=True)
for (i, c) in enumerate(accumulate(T), start=1):
	C.append(int((p + c) / (a + i * b)))
print(sorted(C, reverse=True)[0])


N = int(input())
(A, B) = map(int, input().split())
C = int(input())
D = [None] * N
for i in range(N):
	D[i] = int(input())
D.sort(reverse=True)
numer = C
denom = A
ratio = numer / denom
for i in range(N):
	numer += D[i]
	denom += B
	next_ratio = numer / denom
	if next_ratio <= ratio:
		break
	ratio = next_ratio
print(int(ratio))


n = int(input())
(p_cost, t_cost) = map(int, input().split())
p_cal = int(input())
t_cal = []
for i in range(n):
	t_cal.append(int(input()))
t_cal.sort(reverse=True)
total_cost = p_cost
total_cal = p_cal
max_total_cal_par_doll = total_cal // total_cost
for i in range(n):
	total_cost += t_cost
	total_cal += t_cal[i]
	total_cal_par_doll = total_cal // total_cost
	if max_total_cal_par_doll < total_cal // total_cost:
		max_total_cal_par_doll = total_cal // total_cost
print(max_total_cal_par_doll)


def main():
	t_n = int(input())
	(price_a, price_b) = map(int, input().split())
	cal_a = int(input())
	t_c = sorted([int(input()) for _ in range(t_n)], reverse=True)
	cpd_a = cal_a / price_a
	cal_sum = cal_a
	price_sum = price_a
	b_sum = 0
	for i in range(t_n):
		b_sum += t_c[i]
		new_cpd_a = (cal_a + b_sum) / (price_a + (i + 1) * price_b)
		if new_cpd_a > cpd_a:
			cal_sum += t_c[i]
			price_sum += price_b
			cpd_a = new_cpd_a
	print(int(cal_sum / price_sum))
main()


n = int(input())
(a, b) = map(int, input().split())
c = int(input())
ds = [int(input()) for i in range(n)]
ds.sort(reverse=True)
ans = c // a
for i in range(n):
	c += ds[i]
	ans = max(c // (a + b * (i + 1)), ans)
print(ans)


(N, A, B, C, *D) = map(int, open(0).read().split())
D.sort(reverse=1)
ans = C // A
s = 0
for i in range(N):
	s += D[i]
	ans = max(ans, (C + s) // (A + (i + 1) * B))
print(ans)


import sys
from sys import stdin
from collections import deque
input = stdin.readline
from collections import namedtuple
item = namedtuple('item', ['cal', 'pri'])

def Cond(x, n, items, pizza):
	y = [0] * n
	for i in range(n):
		y[i] = items[i].cal - x * items[i].pri
	y.sort(reverse=True)
	total = pizza.cal - x * pizza.pri
	for i in range(n):
		if y[i] > 0:
			total += y[i]
		else:
			break
	return total >= 0

def main(args):
	N = int(input())
	(A, B) = map(int, input().split())
	C = int(input())
	toppings = []
	for i in range(N):
		toppings.append(item(int(input()), B))
	pizza = item(C, A)
	lb = 0
	ub = 100000.0
	for i in range(100):
		mid = (lb + ub) / 2
		if Cond(mid, N, toppings, pizza):
			lb = mid
		else:
			ub = mid
	print(int(ub))
main(sys.argv[1:])


n = int(input())
(a, b) = map(int, input().split())
c = int(input())
d = sorted([int(input()) for _ in range(n)])[::-1]
e = c // a
for x in d:
	a += b
	c += x
	e = max(e, c // a)
print(e)


N = int(input())
(A, B) = map(int, input().split())
C = int(input())
D = sorted((int(input()) for _ in [0] * N))[::-1]
print(max(((C + sum(D[:i])) // (A + i * B) for i in range(1, N))))