Arkady wants to water his only flower. Unfortunately, he has a very poor watering system that was designed for $n$ flowers and so it looks like a pipe with $n$ holes. Arkady can only use the water that flows from the first hole.

Arkady can block some of the holes, and then pour $A$ liters of water into the pipe. After that, the water will flow out from the non-blocked holes proportionally to their sizes $s_1, s_2, \ldots, s_n$. In other words, if the sum of sizes of non-blocked holes is $S$, and the $i$-th hole is not blocked, $\frac{s_i \cdot A}{S}$ liters of water will flow out of it.

What is the minimum number of holes Arkady should block to make at least $B$ liters of water flow out of the first hole?


-----Input-----

The first line contains three integers $n$, $A$, $B$ ($1 \le n \le 100\,000$, $1 \le B \le A \le 10^4$) — the number of holes, the volume of water Arkady will pour into the system, and the volume he wants to get out of the first hole.

The second line contains $n$ integers $s_1, s_2, \ldots, s_n$ ($1 \le s_i \le 10^4$) — the sizes of the holes.


-----Output-----

Print a single integer — the number of holes Arkady should block.


-----Examples-----
Input
4 10 3
2 2 2 2

Output
1

Input
4 80 20
3 2 1 4

Output
0

Input
5 10 10
1000 1 1 1 1

Output
4



-----Note-----

In the first example Arkady should block at least one hole. After that, $\frac{10 \cdot 2}{6} \approx 3.333$ liters of water will flow out of the first hole, and that suits Arkady.

In the second example even without blocking any hole, $\frac{80 \cdot 3}{10} = 24$ liters will flow out of the first hole, that is not less than $20$.

In the third example Arkady has to block all holes except the first to make all water flow out of the first hole.

Difficulty: interview

Starter code:

Solutions:
n, a, b = [int(x) for x in input().split()]

hs = [int(x) for x in input().split()]

target = 1.0 * hs[0] * a / b

left = sorted(hs[1:])
s = sum(hs)

res = 0
while s > target:
    res += 1
    s -= left[-res]

print(res)


n,i,o = list(map(int,input().split()))
a = list(map(int,input().split()))
f = a[0]
a.pop(0)
a.sort(reverse = True)
s = sum(a)+f
t = 0
y = i*f
#print(y/s)
while(y / s < o):
    s -= a[t]
    t+=1
print(t)


n,A,B = map(int, input().split())
L = list(map(int, input().split()))
a = L[0]
S = sum(L)
L = sorted(L[1:],reverse=True)
count = 0
for i in L:
    if a/S*A>=B:
        break
    else:
        S-=i
        count+=1
print(count)

n, a, b = [int(x) for x in input().split()]
o = []
s = 0
for x in input().split():
    s += int(x)
    o.append(int(x))

s1 = o[0]
o[0] = 0
o.sort()
count = 0
while(s1*a < b*s):
    s -= o.pop()
    count+=1
print(count)


import sys
import math

#n = int(sys.stdin.readline().strip())
n, A, B = list(map(int, sys.stdin.readline().strip().split(' ')))
arr = list(map(int, sys.stdin.readline().strip().split(' ')))
first_hole = arr[0]
sum_holes = sum(arr)
sorted_arr = sorted(arr[1:], reverse = True)

idx = 0
ans = 0
while (first_hole * A) / sum_holes < B:
	sum_holes -= sorted_arr[idx]
	idx += 1
	ans += 1
print(ans)





n, A, B = [int(w) for w in input().split()]
s = [int(w) for w in input().split()]

S = sum(s)
s1, *s = s
s.sort()
s.reverse()
#s1*A/S >= B => S*B <= s1*A
n = 0
while S*B > s1*A:
    S -= s[n]
    n += 1

print(n)


n,a,b=list(map(int,input().split()))
x=[int(x) for x in input().split()]
p=x[0]
d=sum(x)
x.remove(x[0])
c=0
x.sort(reverse=True)

for i in x:
    if((a*p)/d>=b):
        break
    else:
        d-=i
        c+=1
print(c)


def run():
    n, a, b = [int(x) for x in input().split()]
    d = [int(x) for x in input().split()]

    main = d[0]
    other = d[1:]
    other.sort()
    ans = n-1
    s = main
    for x in other:
        if main * a < b * (s+x):
            print(ans)
            return
        s += x
        ans -= 1
    print(0)


run()

num_holes, total_volume, desired_volume = (int(x) for x in input().split())
hole_sizes = [int(x) for x in input().split()]

unblocked_sizes = sum(hole_sizes)
sizes_to_block = list(reversed(sorted(hole_sizes[1:])))
num_blocked = 0

while hole_sizes[0] * total_volume < desired_volume * unblocked_sizes:
    unblocked_sizes -= sizes_to_block[num_blocked]
    num_blocked += 1

print(num_blocked)


n,A,B=map(int,input().split())
hole=[*enumerate(map(int,input().split()))]
si=hole[0][1]
hole.sort(reverse=True,key=lambda x:x[1])
s=0
ans=0
for n,i in hole: s+=i
for n,i in hole:
  if (si*A)//s>=B: break
  if n==0: continue
  s-=i
  ans+=1

print(ans)

n, A, B = list(map(int, input().split()))
s = list(map(int, input().split()))
su = 0
for i in range(n):
    su += s[i]
s2 = s[1:]
we = 0
s2.sort()
s2 = s2[::-1]
kol = 0
if A * s[0] / su >= B:
    print(0)
else:
    for i in range(len(s2)):
        su -= s2[i]
        kol += 1
        if A * s[0] / su >= B:
            print(kol)
            we = 1
            break


n, a, b = list(map(int, input().split()))
ss = list(map(int, input().split()))
s = sum(ss)
s1 = ss[0]
ss = list(reversed(sorted(ss[1:])))

ans = n - 1
for i in range(n):
    if b * s <= a * s1:
        ans = i
        break
    s -= ss[i]
print(ans)



n, a, b = list(map(int, input().split()))
s = list(map(int, input().split()))
x = s[0]
summ = sum(s)
y = []
for i in range(n):
	y.append([s[i], i])
y.sort(reverse = True)
count = 0
index = 0
while (x * a) / summ < b:
	count += 1
	if y[index][1] == 0:
		index += 1
	summ -= y[index][0]
	index += 1
print(count)		



def main():
    [n, a, b] = [int(i) for i in input().split()]
    s = [int(i) for i in input().split()]
    sumAll = 0
    for i in range(n):
        sumAll += s[i]
    rest = s[1:]
    rest.sort(reverse=True)
    thresh = sumAll - s[0] * a / b
    i = 0
    sumBlocked = 0
    while sumBlocked < thresh:
        sumBlocked += rest[i]
        i += 1
    print(i)
def __starting_point():
    main()

__starting_point()

n, A, B = input().split(' ')
n, A, B = int(n), int(A), int(B)
s = [int(i) for i in input().split(' ')]
num = sum(s)
first = s[0]
after = s[1:]
after.sort()
rst = 0
ptr = len(after) - 1
while first / num < B / A:
    num -= after[ptr]
    ptr -= 1
    rst += 1
print(rst)
# print(after)


n, a, b = map(int, input().split())
num = list(map(int, input().split()))
x = num.pop(0)
num.sort()
sum1 = sum(num)
num.reverse()
if (x * a) / (sum1 + x) >= b:
    print(0)
else:
    for i in range(len(num)):
        sum1 -= num[i]
        if (x * a) / (sum1 + x) >= b:
            print(i + 1)
            break


n, a, b = [int(i) for i in input().split(' ')]
sizes = [int(i) for i in input().split(' ')]
st = sum(sizes)
s = (sizes[0] * a) / b
sb = st - s

blockable = sorted(sizes[1:], reverse=True)
blocked_no = 0
blocked_amount = 0
for i in range(len(blockable)):
    if blocked_amount < sb:
        blocked_no += 1
        blocked_amount += blockable[i]
    else:
        break

print(blocked_no)


# python3

def readline(): return tuple(map(int, input().split()))


def main():
    n, a, b = readline()
    s1, *s = readline()

    bound = s1 * (a - b) / b
    for si in sorted(s):
        bound -= si
        if bound < 0:
            break
        n -= 1
    print(n - 1)


main()


n, a, b = list(map(int, input().split()))
holes = list(map(int, input().split()))
s = sum(holes)
f = holes[0]
del holes[0]
holes = sorted(holes)[::-1]
h = 0
for x in range(len(holes)):
    if f * a / s >= b:
        break
    s -= holes[x]
    h += 1
print(h)

n, A, B = list(map(int,input().split()))
otv = list(map(int,input().split()))
one = otv.pop(0)
otv.sort()
su = sum(otv) + one
res = 0
while B * su > A * one:
    res += 1
    su -= otv.pop()
print(res)


_, a, b = list(map(int, input().split()))
s = list(map(int, input().split()))
i = iter(sorted(s[1:], reverse=True))
ssum = sum(s[1:])
s0 = s[0]
cnt = 0

while s and (s0 * a) / (ssum + s0) < b:
    ni = next(i)
    ssum -= ni
    cnt += 1

print(cnt)


n,a,b = map(int, input().split())
s = list(map(int, input().split()))
sm = sum(s)
s0 = s.pop(0)
s = sorted(s)
for i in range(n):
    if i == 0:
        if a * s0 / sm >= b:
            print(0)
            break
    else:
        sm -= s[-i]
        if a * s0 / sm >= b:
            print(i)
            break