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: EASY

Solutions:
(n, i, o) = 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
while y / s < o:
	s -= a[t]
	t += 1
print(t)


import sys

def minp():
	return sys.stdin.readline().strip()

def mint():
	return int(minp())

def mints():
	return map(int, minp().split())
(n, A, B) = mints()
s = list(mints())
s1 = s[0]
S = sum(s)
s = s[1:]
s.sort(reverse=True)
if s1 * A >= B * S:
	print(0)
else:
	for i in range(len(s)):
		S -= s[i]
		if s1 * A >= B * S:
			print(i + 1)
			exit(0)


from itertools import accumulate

def check(p):
	return const / sum_[p] >= B

def binSearch(a, b):
	(left, right) = (a - 1, b + 1)
	while right - left > 1:
		mid = (left + right) // 2
		if check(mid):
			left = mid
		else:
			right = mid
	return n - left - 1
(n, A, B) = map(int, input().split())
s = list(map(int, input().split()))
s = [s[0]] + sorted(s[1:])
sum_ = list(accumulate(s))
const = s[0] * A
print(binSearch(0, n - 1))


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_int = lambda : int(sys.stdin.readline())
pt = lambda x: sys.stdout.write(str(x) + '\n')
(n, a, b) = get_int_list()
lst = get_int_list()
s = a * lst[0] / b
l = sorted(lst[1:])
total = lst[0]
count = 1
for i in l:
	if total + i <= s:
		total += i
		count += 1
	else:
		break
print(n - count)


a = input().split()
b = input().split()
x = 0
z = 0
for i in range(len(a)):
	a[i] = int(a[i])
for i in range(len(b)):
	b[i] = int(b[i])
for i in range(len(b)):
	x += b[i]
n = b[0]
b = b[1:]
b.sort()
while n * a[1] / x < a[2]:
	f = b[-1]
	x -= f
	del b[-1]
	z += 1
print(z)


(n, a, b) = [int(s) for s in input().split()]
ss = [int(s) for s in input().split()]
xs = sorted(ss[1:], reverse=True)
s = sum(ss)
i = 0
while ss[0] * a < b * s:
	s -= xs[i]
	i += 1
print(i)


(n, A, B) = map(int, input().split())
st = input()
a = st.split()
S = 0
for i in range(n):
	a[i] = int(a[i])
	S += a[i]
answer = -1
if a[0] * A / S >= B:
	answer = 0
else:
	b = a[1:]
	b.sort(reverse=True)
	a[1:] = b
	for i in range(1, n):
		S -= a[i]
		if a[0] * A / S >= B:
			answer = i
			break
print(answer)


(n, A, B) = map(int, input().split(' '))
s = list(map(int, input().split(' ')))
adf = s[0]
S = sum(s)
s.remove(adf)
s = sorted(s, reverse=True)
c = 0
t = A * adf / S
i = 0
while t < B and i < n - 1:
	c = c + 1
	S = S - s[i]
	t = A * adf / S
	i = i + 1
print(c)


(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()
n = 0
while S * B > s1 * A:
	S -= s[n]
	n += 1
print(n)


(n, a, b) = map(int, input().split())
x = list(map(int, input().split()))
x1 = x[1:]
x1.sort()
y = sum(x)
while a * x[0] < b * y:
	y -= x1.pop()
print(n - len(x1) - 1)


(n, A, B) = map(int, input().split())
s = [int(i) for i in input().split()]
S = sum(s)
a = s.pop(0)
s.sort(reverse=True)
cnt = 0
for i in range(n - 1):
	if A * a / S >= B:
		break
	else:
		S -= s[i]
		cnt += 1
print(cnt)


(n, a, b) = [int(x) for x in input().split()]
s = [int(x) for x in input().split()]
sq = sum(s)
f = s[0]
s = s[1:]
s.sort(reverse=True)
summa = 0
i = 0
while f * a < b * (sq - summa):
	summa += s[i]
	i += 1
print(i)


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)
main()


(n, A, B) = map(int, input().split())
holes = list(map(int, input().split()))
s1 = holes[0]
holes.remove(s1)
holes.sort()
summ = s1
ans = 0
for i in range(0, len(holes)):
	summ += holes[i]
	if summ > s1 * A / B:
		ans = len(holes) - i
		break
print(ans)


(_, 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 = list(map(int, input().split()))
a = list(map(int, input().split()))
s1 = a[0]
s = sum(a)
del a[0]
a.sort(reverse=True)
tmps = int(s1 * n[1] / n[2])
i = 0
dem = 0
while tmps < s:
	s -= a[i]
	i += 1
	dem += 1
print(dem)


(n, a, b) = map(int, input().split())
x = list(map(int, input().split()))
f = x[0]
x = x[1:]
x.sort()
s = sum(x) + f
current = f * a / s
if current >= b:
	print(0)
else:
	ans = 0
	while current < b:
		s -= x[-1 - ans]
		current = f * a / s
		ans += 1
	print(ans)


cnt = lambda s, i: s.count(i)
ii = lambda : int(input())
si = lambda : input()
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
(n, a, b) = f()
l = il()
sm = sum(l)
k = l.pop(0)
c = 0
l.sort(reverse=True)
for i in range(0, n - 1):
	if k * a / sm < b:
		c += 1
		sm -= l[i]
		l[i] = 0
	else:
		break
print(c)


(n, A, B) = input().split(' ')
n = int(n)
A = int(A)
B = int(B)
L = input().split(' ')
for i in range(len(L)):
	L[i] = int(L[i])
first = L[0]
S = L[1:]
S = sorted(S)[::-1]
count = 0
sumi = sum(S)
k = first * A
for i in S:
	if k / (first + sumi) < B:
		sumi -= i
		count += 1
print(count)


(n, A, B) = map(int, input().split())
s = list(map(int, input().split()))
S = sum(s)
k = s[0]
p = s[1:]
p.sort(reverse=True)
ans = 0
for i in range(len(p)):
	if k * A / S >= B:
		ans = 0
		break
	S -= p[i]
	if k * A / S >= B:
		ans = i + 1
		break
print(ans)


(holes, pour, want) = map(int, input().split())
(h1, *l) = list(map(int, input().split()))
l.sort(reverse=True)
s = sum(l)
for i in range(holes):
	if h1 / (s + h1) * pour >= want:
		print(i)
		break
	s -= l[i]


(n, a, b) = [int(i) for i in input().split()]
s = [int(i) for i in input().split()]
vl = s[0]
s = s[1:]
s.sort(reverse=True)
sm = sum(s) + vl
for i in range(len(s)):
	if vl * a // sm >= b:
		print(i)
		break
	sm = sm - s[i]
	if vl * a // sm >= b:
		print(i + 1)
		break
else:
	print(0)


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
p0 = s[0]
s = s[1:]
max_s = p0 * (a / b - 1)
s.sort()
(s_pip, np) = (sum(s), 0)
while np + 1 <= len(s) and s_pip > max_s:
	s_pip -= s[len(s) - np - 1]
	np += 1
print(np)


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


import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
mod = 10 ** 9 + 7
mod1 = 998244353
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

class TreeNode:

	def __init__(self, k, v):
		self.key = k
		self.value = v
		self.left = None
		self.right = None
		self.parent = None
		self.height = 1
		self.num_left = 1
		self.num_total = 1

class AvlTree:

	def __init__(self):
		self._tree = None

	def add(self, k, v):
		if not self._tree:
			self._tree = TreeNode(k, v)
			return
		node = self._add(k, v)
		if node:
			self._rebalance(node)

	def _add(self, k, v):
		node = self._tree
		while node:
			if k < node.key:
				if node.left:
					node = node.left
				else:
					node.left = TreeNode(k, v)
					node.left.parent = node
					return node.left
			elif node.key < k:
				if node.right:
					node = node.right
				else:
					node.right = TreeNode(k, v)
					node.right.parent = node
					return node.right
			else:
				node.value = v
				return

	@staticmethod
	def get_height(x):
		return x.height if x else 0

	@staticmethod
	def get_num_total(x):
		return x.num_total if x else 0

	def _rebalance(self, node):
		n = node
		while n:
			lh = self.get_height(n.left)
			rh = self.get_height(n.right)
			n.height = max(lh, rh) + 1
			balance_factor = lh - rh
			n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
			n.num_left = 1 + self.get_num_total(n.left)
			if balance_factor > 1:
				if self.get_height(n.left.left) < self.get_height(n.left.right):
					self._rotate_left(n.left)
				self._rotate_right(n)
			elif balance_factor < -1:
				if self.get_height(n.right.right) < self.get_height(n.right.left):
					self._rotate_right(n.right)
				self._rotate_left(n)
			else:
				n = n.parent

	def _remove_one(self, node):
		replacement = node.left or node.right
		if node.parent:
			if AvlTree._is_left(node):
				node.parent.left = replacement
			else:
				node.parent.right = replacement
			replacement.parent = node.parent
			node.parent = None
		else:
			self._tree = replacement
			replacement.parent = None
		node.left = None
		node.right = None
		node.parent = None
		self._rebalance(replacement)

	def _remove_leaf(self, node):
		if node.parent:
			if AvlTree._is_left(node):
				node.parent.left = None
			else:
				node.parent.right = None
			self._rebalance(node.parent)
		else:
			self._tree = None
		node.parent = None
		node.left = None
		node.right = None

	def remove(self, k):
		node = self._get_node(k)
		if not node:
			return
		if AvlTree._is_leaf(node):
			self._remove_leaf(node)
			return
		if node.left and node.right:
			nxt = AvlTree._get_next(node)
			node.key = nxt.key
			node.value = nxt.value
			if self._is_leaf(nxt):
				self._remove_leaf(nxt)
			else:
				self._remove_one(nxt)
			self._rebalance(node)
		else:
			self._remove_one(node)

	def get(self, k):
		node = self._get_node(k)
		return node.value if node else -1

	def _get_node(self, k):
		if not self._tree:
			return None
		node = self._tree
		while node:
			if k < node.key:
				node = node.left
			elif node.key < k:
				node = node.right
			else:
				return node
		return None

	def get_at(self, pos):
		x = pos + 1
		node = self._tree
		while node:
			if x < node.num_left:
				node = node.left
			elif node.num_left < x:
				x -= node.num_left
				node = node.right
			else:
				return (node.key, node.value)
		raise IndexError('Out of ranges')

	@staticmethod
	def _is_left(node):
		return node.parent.left and node.parent.left == node

	@staticmethod
	def _is_leaf(node):
		return node.left is None and node.right is None

	def _rotate_right(self, node):
		if not node.parent:
			self._tree = node.left
			node.left.parent = None
		elif AvlTree._is_left(node):
			node.parent.left = node.left
			node.left.parent = node.parent
		else:
			node.parent.right = node.left
			node.left.parent = node.parent
		bk = node.left.right
		node.left.right = node
		node.parent = node.left
		node.left = bk
		if bk:
			bk.parent = node
		node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
		node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
		node.num_left = 1 + self.get_num_total(node.left)

	def _rotate_left(self, node):
		if not node.parent:
			self._tree = node.right
			node.right.parent = None
		elif AvlTree._is_left(node):
			node.parent.left = node.right
			node.right.parent = node.parent
		else:
			node.parent.right = node.right
			node.right.parent = node.parent
		bk = node.right.left
		node.right.left = node
		node.parent = node.right
		node.right = bk
		if bk:
			bk.parent = node
		node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
		node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
		node.num_left = 1 + self.get_num_total(node.left)

	@staticmethod
	def _get_next(node):
		if not node.right:
			return node.parent
		n = node.right
		while n.left:
			n = n.left
		return n

class SegmentTree1:

	def __init__(self, data, default=300006, func=lambda a, b: min(a, b)):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class SegmentTree:

	def __init__(self, data, default=0, func=lambda a, b: a + b):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class Factorial:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorials = [1, 1]
		self.invModulos = [0, 1]
		self.invFactorial_ = [1, 1]

	def calc(self, n):
		if n <= -1:
			print('Invalid argument to calculate n!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.factorials):
			return self.factorials[n]
		nextArr = [0] * (n + 1 - len(self.factorials))
		initialI = len(self.factorials)
		prev = self.factorials[-1]
		m = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * i % m
		self.factorials += nextArr
		return self.factorials[n]

	def inv(self, n):
		if n <= -1:
			print('Invalid argument to calculate n^(-1)')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		p = self.MOD
		pi = n % p
		if pi < len(self.invModulos):
			return self.invModulos[pi]
		nextArr = [0] * (n + 1 - len(self.invModulos))
		initialI = len(self.invModulos)
		for i in range(initialI, min(p, n + 1)):
			next = -self.invModulos[p % i] * (p // i) % p
			self.invModulos.append(next)
		return self.invModulos[pi]

	def invFactorial(self, n):
		if n <= -1:
			print('Invalid argument to calculate (n^(-1))!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.invFactorial_):
			return self.invFactorial_[n]
		self.inv(n)
		nextArr = [0] * (n + 1 - len(self.invFactorial_))
		initialI = len(self.invFactorial_)
		prev = self.invFactorial_[-1]
		p = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * self.invModulos[i % p] % p
		self.invFactorial_ += nextArr
		return self.invFactorial_[n]

class Combination:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorial = Factorial(MOD)

	def ncr(self, n, k):
		if k < 0 or n < k:
			return 0
		k = min(k, n - k)
		f = self.factorial
		return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD

def powm(a, n, m):
	if a == 1 or n == 0:
		return 1
	if n % 2 == 0:
		s = powm(a, n // 2, m)
		return s * s % m
	else:
		return a * powm(a, n - 1, m) % m

def sort_list(list1, list2):
	zipped_pairs = zip(list2, list1)
	z = [x for (_, x) in sorted(zipped_pairs)]
	return z

def product(l):
	por = 1
	for i in range(len(l)):
		por *= l[i]
	return por

def binarySearchCount(arr, n, key):
	left = 0
	right = n - 1
	count = 0
	while left <= right:
		mid = int((right + left) / 2)
		if arr[mid] <= key:
			count = mid + 1
			left = mid + 1
		else:
			right = mid - 1
	return count

def countdig(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def binary(x, length):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y

def countGreater(arr, n, k):
	l = 0
	r = n - 1
	leftGreater = n
	while l <= r:
		m = int(l + (r - l) / 2)
		if arr[m] >= k:
			leftGreater = m
			r = m - 1
		else:
			l = m + 1
	return n - leftGreater

class TrieNode:

	def __init__(self):
		self.children = [None] * 26
		self.isEndOfWord = False

class Trie:

	def __init__(self):
		self.root = self.getNode()

	def getNode(self):
		return TrieNode()

	def _charToIndex(self, ch):
		return ord(ch) - ord('a')

	def insert(self, key):
		pCrawl = self.root
		length = len(key)
		for level in range(length):
			index = self._charToIndex(key[level])
			if not pCrawl.children[index]:
				pCrawl.children[index] = self.getNode()
			pCrawl = pCrawl.children[index]
		pCrawl.isEndOfWord = True

	def search(self, key):
		pCrawl = self.root
		length = len(key)
		for level in range(length):
			index = self._charToIndex(key[level])
			if not pCrawl.children[index]:
				return False
			pCrawl = pCrawl.children[index]
		return pCrawl != None and pCrawl.isEndOfWord

class Node:

	def __init__(self, data):
		self.data = data
		self.count = 0
		self.left = None
		self.right = None

class BinaryTrie:

	def __init__(self):
		self.root = Node(0)

	def insert(self, pre_xor):
		self.temp = self.root
		for i in range(31, -1, -1):
			val = pre_xor & 1 << i
			if val:
				if not self.temp.right:
					self.temp.right = Node(0)
				self.temp = self.temp.right
				self.temp.count += 1
			if not val:
				if not self.temp.left:
					self.temp.left = Node(0)
				self.temp = self.temp.left
				self.temp.count += 1
		self.temp.data = pre_xor

	def query(self, xor):
		self.temp = self.root
		for i in range(31, -1, -1):
			val = xor & 1 << i
			if not val:
				if self.temp.left and self.temp.left.count > 0:
					self.temp = self.temp.left
				elif self.temp.right:
					self.temp = self.temp.right
			elif self.temp.right and self.temp.right.count > 0:
				self.temp = self.temp.right
			elif self.temp.left:
				self.temp = self.temp.left
			self.temp.count -= 1
		return xor ^ self.temp.data
(n, A, B) = map(int, input().split())
l = list(map(int, input().split()))
first = l[0]
l = l[1:]
l.sort(reverse=True)

def find(x):
	su = sum(l) + first
	for i in range(x):
		su -= l[i]
	if first * A >= su * B:
		return True
	return False
st = 0
end = n - 1
ans = n - 1
while st <= end:
	mid = (st + end) // 2
	if find(mid) == True:
		ans = mid
		end = mid - 1
	else:
		st = mid + 1
print(ans)


(n, a, b) = map(int, input().split())
(x, *l) = map(int, input().split())
l.sort()
c = 0
s = sum(l)
p = x * a / b - x
while p < s:
	c += 1
	s -= l.pop()
print(c)


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
c = sum(s)
d = s[0]
s.remove(d)
s.sort()
s.insert(0, d)
while len(s) > 1:
	e = d * a // c
	if e < b:
		c = c - s[-1]
		s.pop()
	else:
		break
print(n - len(s))


(n, a, b) = map(int, input().split())
w = list(map(int, input().split()))
s = w[0] * a / b
b = w[1:]
b.sort()
c = [w[0]]
c.extend(b)
p = 0
flag = 0
for i in range(n):
	p += c[i]
	if p > s:
		print(n - i)
		flag = 1
		break
if flag == 0:
	print('0')


(n, a, b) = map(int, input().split())
l = list(map(int, input().split()))
s = sum(l)
x = l[0]
if n == 1:
	print(0)
else:
	l = l[1:]
	l.sort()
	l.reverse()
	i = 0
	while s * b > a * x and i < n - 1:
		s -= l[i]
		i += 1
	print(i)


(n, A, B) = map(int, input().split())
s = list(map(int, input().split()))
s0 = s[0]
total = sum(s)
s.sort(reverse=True)
i = 0
flag = 0
count = 0
while i < len(s) and s0 / total < B / A:
	if flag == 0 and s[i] == s0:
		flag = 1
		i += 1
		continue
	total -= s[i]
	i += 1
	count += 1
print(count)


def check(key, a, b, s):
	val = key * a / s
	if val >= b:
		return True
	return False

def main():
	(n, a, b) = map(int, input().split())
	tmp = list(map(int, input().split()))
	key = tmp[0]
	arr = sorted(tmp[1:])
	s = key
	i = -1
	res = n - 1
	while True:
		tmp = check(key, a, b, s)
		if not tmp:
			return res + 1
		i += 1
		if i >= len(arr):
			return res
		s += arr[i]
		res -= 1
print(main())


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


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


(n, A, B) = 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) = [int(x) for x in input().split()]
s = list(map(int, input().split()))
t = sum(s)
k = 0
r = sorted(s[1:])
for i in range(n - 1):
	if s[0] * a // t < b:
		t -= r[n - i - 2]
		k += 1
print(k)


(n, A, B) = map(int, input().split(' '))
size = [int(x) for x in input().split(' ')]
s = sum(size)
first = size[0]
spilled_first = first * A / s
closed = 0
size = sorted(size[1:], reverse=True)
for k in size:
	if spilled_first >= B:
		break
	s = s - k
	closed += 1
	spilled_first = first * A / s
print(closed)


(n, a, b) = map(int, input().split())
li = list(map(int, input().split()))
s = sum(li)
fh = li[0]
li.remove(li[0])
li.sort()
li = li[::-1]
count = 0
if fh * a / s < b:
	i = 0
	while fh * a / s < b:
		s -= li[i]
		i += 1
		count += 1
print(count)


(n, A, B) = map(int, input().split())
(s1, *s) = map(int, input().split())
s.sort(reverse=True)
total = sum(s[:]) + s1
hole_block = 0
while True:
	judgement = s1 * A / total
	if judgement >= B:
		print(hole_block)
		break
	hole_block += 1
	total -= s[hole_block - 1]


(a, b, c) = map(int, input().split())
l = list(map(int, input().split()))
S = l[0] * b / c
k = 0
t = l[1:]
l1 = sum(l)
if l1 <= S:
	print(0)
else:
	t.sort(reverse=True)
	for i in range(a - 1):
		t1 = t[i]
		l1 = l1 - t1
		if l1 <= S:
			break
	print(i + 1)


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
c = s[1:]
c.sort()
f = 0
e = s[0]
for x in c:
	e += x
while True:
	if s[0] * (a / e) >= b:
		break
	else:
		f += 1
		e -= c[-1]
		c.pop()
print(f)


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


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
s0 = s[0]
s = s[1:]
s = sorted(s)
sm = s0
for i in range(n - 1):
	sm += s[i]
	if s0 / sm * a < b:
		print(n - 1 - i)
		exit()
print(0)


MAX = 10000000
[n, A, B] = list(map(int, input().split()))
arr = list(map(int, input().split()))
s = arr[0]
arr[0] = -1
arr.sort()
arr[0] = s
sm = 0
sol = MAX
for j in range(n):
	sm += arr[j]
	if s * A / sm >= B:
		sol = min(sol, n - j - 1)
print(sol)


(n, a, b) = tuple(map(int, input().split()))
arr = list(map(int, input().split()))
p = arr[0]
arr.remove(p)
x = p * a / b
x -= p
count = 1
arr.sort()
i = 0
while x > 0 and i < n - 1:
	x -= arr[i]
	count += 1
	i += 1
if x > 0:
	res = n
elif x == 0:
	res = count
else:
	res = count - 1
print(n - res)


(n, a, b) = map(int, input().split())
u = list(map(int, input().split()))
p = u[0]
u = u[1:] + [0]
u.sort()
u[0] = p
ok = True
for i in range(1, n):
	u[i] += u[i - 1]
	ans = p * a / u[i]
	if ans < b:
		print(n - i)
		ok = False
		break
if ok:
	print(0)


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


(n, A, B) = map(int, input().split())
s = [int(x) for x in input().split()]
first = s[0]
del s[0]
s2 = []
s2 = sorted(s, reverse=True)
total = sum(s2) + first
j = 0
while 1:
	need = first * A / total
	if j < n - 1:
		total = total - s2[j]
	if need >= B:
		print(j)
		break
	else:
		j += 1


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


(n, a, b) = map(int, input().split())
mas = list(map(int, input().split()))
s = sum(mas)
e = mas[0] * a
mas = mas[1:]
mas.sort()
mas.reverse()
from sys import exit
for i in range(n - 1):
	if e / s >= b:
		print(i)
		exit()
	s -= mas[i]
print(n - 1)


I = lambda : map(int, input().split())
(n, a, b) = I()
(x, *s) = I()
s = sorted(s)[::-1]
S = x + sum(s)
for i in range(n):
	if i:
		S -= s[i - 1]
	if x * a >= S * b:
		break
print(i)


(a, b, c) = [int(i) for i in input().split()]
d = [int(i) for i in input().split()]
e = sorted(d[1:], reverse=True)
s = sum(e)
ans = 0
for i in range(0, len(e)):
	if b * d[0] / (d[0] + s) >= c:
		break
	s = s - e[i]
	ans = ans + 1
	if b * d[0] / (d[0] + s) >= c:
		break
print(ans)


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


(a, b, c) = list(map(int, input().split()))
f = list(map(int, input().split()))
g = f[0]
s = sum(f)
f.remove(f[0])
d = list(reversed(sorted(f)))
e = 0
if b * g / s >= c:
	print(e)
else:
	for j in range(0, a):
		s -= d[j]
		if b * g / s >= c:
			print(j + 1)
			break


(x, y, z) = map(int, input('').split())
ar = list(map(int, input('').split()))
ar1 = sorted(ar[1:])
ar1 = ar1[::-1]
sumtot = sum(ar)
while y * ar[0] < z * sumtot:
	sumtot = sumtot - ar1.pop(0)
print(len(ar) - len(ar1) - 1)


(n, a, b) = map(int, input().split())
ar = list(map(int, input().split()))
first = ar[0]
tot = sum(ar)
ar = sorted(ar[1:], reverse=True)
cnt = 0
if first * a // tot < b:
	for i in range(n - 1):
		cnt += 1
		tot -= ar[i]
		if first * a // tot >= b:
			break
print(cnt)


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
q = s[0]
su = sum(s)
del s[0]
s.sort()
i = n - 2
while q * a / su < b:
	su -= s[i]
	i -= 1
print(n - 2 - i)


def f(l1, l2):
	(n, a, b) = l1
	s = sum(l2)
	l = l2[1:]
	l.sort(reverse=True)
	i = 0
	while b * s > l2[0] * a:
		s -= l[i]
		i += 1
	return i
l1 = list(map(int, input().split()))
l2 = list(map(int, input().split()))
print(f(l1, l2))


I = lambda : map(int, input().split())
(n, A, B) = I()
(s1, *S) = I()
if S:
	S = sorted(S)
	total = s1
	i = 0
	while i < n - 1 and s1 * A >= B * (total + S[i]):
		total += S[i]
		i += 1
	print(n - i - 1)
else:
	print(0)


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
first = s[0]
sum_all = sum(s)
no_first = s[1:]
no_first.sort(reverse=True)
ans = 0
for i in range(n - 1):
	if a * first / sum_all >= b:
		break
	else:
		sum_all -= no_first[i]
		ans += 1
print(ans)


(n, A, B) = map(int, input().rstrip().split())
l = list(map(int, input().rstrip().split()))
se = l[1:]
se.sort(reverse=True)
re = A * l[0] / B
se.insert(0, l[0])
S = sum(l)
if S <= re:
	print(0)
	exit()
c = 0
for i in range(1, n):
	S -= se[i]
	if S <= re:
		print(c + 1)
		exit()
	c += 1


(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


(n, a, b) = map(int, input().split())
ar = list(map(int, input().split()))
su = sum(ar)
ark = ar.pop(0)
ar.sort(reverse=True)
if ark / su * a >= b:
	print(0)
else:
	flag = 0
	br = [ar[0]]
	for i in range(1, n - 1):
		br.append(br[-1] + ar[i])
	for i in range(n - 1):
		if ark * a / (su - br[i]) >= b:
			print(i + 1)
			flag = 1
			break
	if flag == 0:
		print(n - 1)


(n, a, b) = list(map(int, input().split()))
s = list(map(int, input().split()))
k = s[0]
x = a * s[0] / b
c = 0
s.remove(k)
sum_of_all = sum(s)
s = sorted(s, reverse=True)
while sum_of_all + k > x:
	sum_of_all -= s[0]
	s.remove(s[0])
	c += 1
print(c)


MIS = lambda : map(int, input().split())
(n, A, B) = MIS()
hole = list(MIS())
s1 = hole[0]
hole = sorted(hole[1:], reverse=True)
size = sum(hole) + s1
if s1 * A >= size * B:
	print(0)
	exit()
for i in range(n - 1):
	size -= hole[i]
	if s1 * A >= size * B:
		print(i + 1)
		break


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


(n, Vin, Vvoulu) = map(int, input().split())
sizes = list(map(int, input().split()))
L = len(sizes)
lim = sizes[0] * Vin / Vvoulu
minabloquer = sum(sizes[:]) - lim
sofar = 0
count = 0
renorma = sizes[1:]
renorma.sort(reverse=True)
total = 0
co = 0
while total < minabloquer:
	total += renorma[co]
	co += 1
print(co)


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


import math
import queue
(n, a, b) = [int(x) for x in input().split()]
s = [int(x) for x in input().split()]
f = s[0]
sums = sum(s)
s = reversed(sorted(s[1:]))
ans = 0
for data in s:
	if a * f / (sums * 1.0) >= b:
		break
	sums -= data
	ans += 1
print(ans)


def watering_plants(n, poured, goal, seq):
	blocked = 0
	first_hole = seq.pop(0)
	seq.sort()
	divisor = sum(seq) + first_hole
	while first_hole * poured / divisor < goal:
		divisor -= seq[-1]
		seq.pop(-1)
		blocked += 1
	return blocked
(n, poured, goal) = list(map(int, input().split()))
seq = list(map(int, input().split()))
print(watering_plants(n, poured, goal, seq))


from math import ceil
(n, a, b) = [int(i) for i in input().split()]
l = [int(i) for i in input().split()]
d = l[:]
d[0] = 0
d.sort()
for i in range(1, n):
	d[i] += d[i - 1]
for i in range(n - 1, -1, -1):
	x = a * l[0] / (d[i] + l[0])
	if x >= b:
		print(n - 1 - i)
		exit(0)


import sys
import math
(n, A, B) = 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)


def solve(a, b, s):
	first = s[0]
	total = sum(s)
	s = s[1:]
	s.sort(reverse=True)
	i = 0
	while first * a / total < b:
		total -= s[i]
		i += 1
	return i
(n, a, b) = map(int, input().split())
s = [int(x) for x in input().split()]
print(solve(a, b, s))


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


import bisect
import heapq
import math
import collections
import sys
import copy
from functools import reduce
import decimal
from io import BytesIO, IOBase
import os
sys.setrecursionlimit(10 ** 9)
decimal.getcontext().rounding = decimal.ROUND_HALF_UP
graphDict = collections.defaultdict
queue = collections.deque

class Graphs:

	def __init__(self):
		self.graph = graphDict(list)

	def add_edge(self, u, v):
		self.graph[u].append(v)

	def dfs_utility(self, nodes, visited_nodes):
		visited_nodes.add(nodes)
		for neighbour in self.graph[nodes]:
			if neighbour not in visited_nodes:
				self.dfs_utility(neighbour, visited_nodes)
			else:
				return neighbour

	def dfs(self, node):
		Visited = set()
		self.dfs_utility(node, Visited)

	def bfs(self, node):
		visited = set()
		if node not in visited:
			queue.append(node)
			visited.add(node)
		while queue:
			parent = queue.popleft()
			print(parent)
			for item in self.graph[parent]:
				if item not in visited:
					queue.append(item)
					visited.add(item)

def rounding(n):
	return int(decimal.Decimal(f'{n}').to_integral_value())

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def inp():
	return sys.stdin.readline().strip()

def map_inp(v_type):
	return map(v_type, inp().split())

def list_inp(v_type):
	return list(map_inp(v_type))
(n, A, B) = map_inp(int)
s = queue(list_inp(int))
if n == 1:
	print(0)
else:
	total = sum(s)
	first = s[0]
	s.popleft()
	s = list(s)
	heapq._heapify_max(s)
	ans = 0
	while first * A // total < B and len(s) > 0:
		total -= heapq._heappop_max(s)
		ans += 1
	print(ans)


(n, A, B) = map(int, input().strip().split())
lst = list(map(int, input().strip().split()))[:n]
t = sum(lst)
lst = lst[:1] + sorted(lst[1:])
while A * lst[0] < B * t:
	t -= lst.pop()
print(n - len(lst))


(n, A, B) = map(int, input().split())
hole = list(map(int, input().split()))
h1 = hole[0]
s1 = hole.count(h1)
tong = sum(hole)
S = h1 * A / B
hole.sort()
hole.reverse()
rs = 0
for i in hole:
	if S >= tong:
		break
	if i <= tong:
		if i == h1:
			if s1 == 1:
				continue
			else:
				s1 -= 1
		tong -= i
		rs += 1
print(rs)


x = list(map(int, input().split()))
y = list(map(int, input().split()))
s = 0
c = y.pop(0)
y.sort()
p = sum(y)
while c * x[1] / (p + c) < x[2]:
	s += 1
	p -= y.pop(-1)
print(s)


(n, a, b) = map(int, input().split())
d = list(map(int, input().split()))
d1 = d[1:]
d1.sort()
ans = 0
sd1 = sum(d1)
while b > d[0] * a / (sd1 + d[0]):
	sd1 -= d1.pop()
	ans += 1
print(ans)


import sys
sys.setrecursionlimit(2000)
from collections import Counter

def solution(n, A, B, s):
	summ = sum(s)
	val = s[0]
	s = sorted(s[1:], reverse=True)
	count = 0
	frac = val / summ
	while A * frac < B:
		summ -= s[count]
		count += 1
		frac = val / summ
	print(count)
(n, A, B) = [int(val) for val in input().split()]
s = [int(val) for val in input().split()]
solution(n, A, B, s)


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
ss = sum(s)
l = sorted(s[1:], reverse=True)
i = 0
while s[0] * a / ss < b:
	ss -= l[i]
	i += 1
print(i)


(n, A, B) = list(map(int, input().split()))
s = list(map(int, input().split()))
holes = sorted(s[1:])
holes.reverse()
t = sum(holes)
if (t + s[0]) * B <= s[0] * A:
	print(0)
	exit(0)
for i in range(n - 1):
	t -= holes[i]
	if (t + s[0]) * B <= s[0] * A:
		print(i + 1)
		exit(0)


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


import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')
(n, a, b) = map(int, input().split())
array = list(map(int, input().split()))
array = array[:1] + sorted(array[1:])
tot = sum(array)
while a * array[0] < b * tot:
	tot -= array.pop()
print(n - len(array))


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


(n, A, B) = map(int, input().split())
hole = list(map(int, input().split()))
first = hole[0]
hole[1:] = sorted(hole[1:], reverse=True)
Sum = 0
for i in range(len(hole)):
	Sum += hole[i]
c = 0
for i in range(1, len(hole)):
	if hole[0] * A / Sum < B:
		c += 1
		Sum -= hole[i]
	else:
		break
print(c)


(n, A, B) = map(int, input().split())
arr = list(map(int, input().split()))
required = arr[0] * A / B
summ = arr[0]
del arr[0]
arr.sort(reverse=True)
summ += sum(arr)
count = 0
while summ > required and count < len(arr):
	summ -= arr[count]
	count += 1
print(count)


def _input():
	return map(int, input().strip().split())

def _print(s):
	print(''.join(map(str, s)))
(n, A, B) = _input()
s = list(_input())
r = list(s[1:])
r.sort(reverse=True)
tot = sum(s)
if s[0] * A >= B * tot:
	print(0)
	exit(0)
cur = tot
for i in range(len(r)):
	cur -= r[i]
	if s[0] * A >= B * cur:
		print(i + 1)
		exit(0)


(qtd, vin, vmfr) = map(int, input().split())
holes = list(map(int, input().split()))
total = sum(holes)
holes_sorted = sorted(holes[1:], reverse=True)
holes_closed = 0
while True:
	vfr = holes[0] * vin / total
	if vfr >= vmfr:
		print(holes_closed)
		break
	holes_closed += 1
	total -= holes_sorted[holes_closed - 1]


(n, a, b) = map(int, input().split())
ar = list(map(int, input().split()))
summ = sum(ar)
aa = ar.pop(0)
ar.sort()
if aa * a / summ >= b:
	print('0')
else:
	n -= 2
	con = 1
	summ -= ar[n]
	while aa * a / summ < b:
		n -= 1
		summ -= ar[n]
		con += 1
	print(con)


import sys
import math
(n, A, B) = map(int, input().split())
s = [int(x) for x in input().strip().split()]
sorta = s[1:]
sorta = sorted(sorta, reverse=True)
cota = 0
suma = sum(s)
if B == 0 or n == 0:
	print(cota)
elif math.floor(s[0] * A / sum(s)) >= B:
	print(cota)
else:
	for i in range(0, n):
		suma -= sorta[i]
		cota += 1
		if math.floor(s[0] * A / suma) >= B:
			print(cota)
			break


(a, b, c) = map(int, input().split())
z = list(map(int, input().split()))
x = z[1:]
x.sort(reverse=True)
(q, e) = (z[0] + sum(x), 0)
for i in x:
	w = z[0] * b / q
	if w >= c:
		a = -1
		break
	else:
		q -= i
		e += 1
print(e)


(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) = [int(x) for x in input().split(' ')]
data = [int(x) for x in input().split(' ')]
s = sum(data)
first = data.pop(0)
if first * a / s >= b:
	print(0)
else:
	data.sort()
	s -= data.pop()
	c = 1
	while first * a / s < b:
		s -= data.pop()
		c += 1
	print(c)


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
sk = s[0] * a / b
t = s[0]
del s[0]
s.sort()
ans = 1
i = 0
if sum(s) + t <= sk:
	print(0)
else:
	while t <= sk:
		if t + s[i] > sk:
			break
		ans += 1
		t += s[i]
		i += 1
	print(n - ans)


(n, A, B) = map(int, input().split())
x = list(map(int, input().split()))
init = x[0]
del x[0]
x.sort(reverse=True)
ans = 0
S = sum(x) + init
for i in range(n - 1):
	if init * A / S < B:
		ans += 1
		S -= x[i]
		if i == n - 2:
			print(ans)
			exit()
	else:
		print(ans)
		exit()
print(0)


X = list(map(int, input().split()))
Holes = list(map(int, input().split()))
(First, SUM, Holes, i) = (Holes[0], sum(Holes), list(sorted(Holes[1:], reverse=True)), 0)
while First * X[1] / SUM < X[2]:
	(SUM, i) = (SUM - Holes[i], i + 1)
print(i)


(n, a, b) = map(int, input().split())
l = [int(s) for s in input().split()]
k = sum(l)
k1 = l[0]
l.pop(0)
l.sort(reverse=True)
if a * k1 // k >= b:
	print(0)
else:
	for i in range(n):
		k = k - l[i]
		if a * k1 // k >= b:
			print(i + 1)
			break


(holes, pour, want) = map(int, input().split())
(h1, *l) = list(map(int, input().split()))
l.sort()
sum = h1
if holes == 1:
	print(0)
else:
	for i in range(holes - 1):
		if h1 / (l[i] + sum) * pour < want:
			print(holes - i - 1)
			break
		elif i == holes - 2:
			print(0)
		else:
			sum += l[i]


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
summ = sum(s)
first = s[0]
curr = s[0] * a / summ
if curr >= b:
	print(0)
else:
	s.pop(0)
	s.sort(reverse=True)
	i = 0
	c = 0
	while curr < b and i <= n - 2:
		summ -= s[i]
		c += 1
		curr = first * a / summ
		i += 1
	print(c)


from math import ceil
(n, A, B) = map(int, input().split())
s = [int(i) for i in input().split()]
p = s[1:]
p.sort(reverse=True)
t = sum(s)
su = s[0] * A / B
k = t - su
g = 0
i = 0
h = len(p)
r = True
while r:
	if s[0] * A / sum(s) >= B:
		r = False
		break
	m = ceil((i + h) / 2)
	S = sum(p[:m])
	if S >= k and sum(p[:m - 1]) < k:
		g = m
		break
	elif S < k:
		i = m
	else:
		h = m
print(g)


import heapq
(n, A, B) = map(int, input().split())
holes = list(map(int, input().split()))
tmpSum = sum(holes)
s1 = holes[0]
del holes[0]
for i in range(n - 1):
	holes[i] = 0 - holes[i]
heapq.heapify(holes)
ans = 0
while True:
	if s1 * A >= B * tmpSum:
		break
	top = heapq.heappop(holes)
	tmpSum += top
	ans += 1
print(ans)


(n, a, b) = map(int, input().split())
l = [*map(int, input().split())]
s = l[0]
del l[0]
x = s * a // b - s
l.sort()
net = res = 0
for e in l:
	if net + e > x:
		break
	net += e
	res += 1
print(n - 1 - res)


(n, A, B) = map(int, input().split())
l = list(map(int, input().split()))
s = sum(l)
s1 = []
s1 = l[1:]
s1.sort(reverse=True)
req = l[0] * A // B
if req >= s:
	print(0)
else:
	c = 0
	for i in s1:
		c += 1
		s -= i
		if s <= req:
			print(c)
			break


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


(n, s, a) = map(int, input().split())
r = lambda : list(map(int, input().split()))
arr = r()
t = sum(arr)
f = arr[0]
arr = arr[1:]
arr.sort(reverse=True)
c = 0
for i in range(n - 1):
	if f * s / t >= a:
		break
	t -= arr[i]
	c += 1
print(c)


(n, A, B) = list(map(int, input().split(' ')))
sq = list(map(int, input().split(' ')))
if A * sq[0] / sum(sq) >= B:
	print(0)
else:
	s = list()
	s.append(sq[0])
	s.extend(sorted(sq[1:]))
	lev = 1
	pra = n - 1
	while lev != pra:
		s8 = sum(s[:(lev + pra) // 2 + 1])
		if A * s[0] >= B * s8:
			lev = (lev + pra) // 2 + 1
			if A * s[0] == B * s8:
				break
		else:
			pra = (lev + pra) // 2
	print(n - lev)


(n, A, B) = map(int, input().split())
s = []
tS = 0
for i in input().split():
	s.append(int(i))
	tS = tS + int(i)
s1 = s[0]
s = s[1:]
s.sort(reverse=True)
w = 0
w1 = 0
b = 0
bl = 0
while True:
	w1 = A * (s1 / (tS - bl))
	if w1 >= B:
		break
	if b > len(s) - 1:
		print(b)
		exit()
	bl = bl + s[b]
	b += 1
print(b)


from bisect import bisect_right

def get_ints():
	return map(int, input().split())

def get_list():
	return list(map(int, input().split()))

def min_value_greater_than(arr, k):
	arr.sort()
	return arr[bisect_right(arr, k)]
(n, A, B) = get_ints()
s = get_list()
l = s[1:]
l.sort()
S = s[0] * A / B - s[0]
a = sum(l)
cnt = 0
while a > S:
	cnt += 1
	a -= l.pop()
print(cnt)


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
(c, h, j) = (sum(s), 0, 0)
k = s[1:]
k.sort(reverse=True)
for i in k:
	if a * s[0] / c >= b:
		break
	c -= i
	j += 1
print(j)


(a, b, c) = map(int, input().rstrip().split(' '))
l = list(map(int, input().rstrip().split(' ')))
S = sum(l)
f = l.pop(0)
l.sort(reverse=True)
p = b * f
i = 0
while p / S < c:
	S = S - l[i]
	i = i + 1
print(i)


(n, a, b) = map(int, input().split())
l1 = list(map(int, input().split()))
s = sum(l1)
x = l1[0]
l1 = l1[1:]
l1.sort()
l1 = l1[::-1]
count = 0
for item in l1:
	if x * a / s >= b:
		break
	else:
		s -= item
		count += 1
print(count)


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


li = input().split(' ')
n = int(li[0])
a = int(li[1])
b = int(li[2])
li = input().split(' ')
li = list(map(int, li))
remain_S = sorted(li[1:], reverse=True)
s = sum(li)
flow = li[0] * a / s
if flow >= b:
	print(0)
	exit()
for x in range(1, len(li) - 1):
	s += -remain_S[x - 1]
	flow = li[0] * a / s
	if flow >= b:
		print(x)
		exit()
print(n - 1)


(n, A, B) = map(int, input().split())
Raz = list(map(int, input().split()))
x = Raz.pop(0)
Raz.sort()
s = sum(Raz)
k = 0
while x * A / (s + x) < B:
	k += 1
	s -= Raz.pop(-1)
print(k)


x = list(map(int, input().split()))
holes = list(map(int, input().split()))
total = 0
sum = 0
for i in range(x[0]):
	total += holes[i]
initialhole = holes[0]
holes.sort()
point = 0
for i in range(x[0] - 1, -1, -1):
	if holes[i] == initialhole and point == 0:
		point = 1
	elif initialhole * x[1] / total < x[2]:
		total -= holes[i]
		sum += 1
	else:
		break
print(sum)


(n, a, b) = map(int, input().split())
l = list(map(int, input().split()))
x = sum(l)
l1 = l[1:]
l1.sort()
while a * l[0] / x < b:
	x -= l1.pop()
print(n - len(l1) - 1)


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
ma = sum(s)
ss = s[0]
s.pop(0)
s.sort()
t = 0
for i in range(len(s) - 1, -1, -1):
	if ss * a / ma >= b:
		break
	ma -= s[i]
	t += 1
print(t)


(n, a, b) = tuple(map(int, input().split()))
holes = list(map(int, input().split()))
s = sum(holes)
for (index, size) in enumerate(sorted(holes[1:], reverse=True), start=1):
	if holes[0] * a / s >= b:
		print(index - 1)
		break
	s -= size
else:
	print(n - 1)


import sys
read = lambda : map(int, sys.stdin.buffer.readline().split())
(n, A, B) = read()
v = list(read())
f = v[0]
s = sum(v)
v.pop(0)
v.sort(reverse=True)
for i in range(n):
	if f * A >= B * s:
		print(i)
		break
	s -= v[i]


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
k = s[0] * a / b
l = s[0]
s.sort()
z = s.index(l)
s = s[:z] + s[z + 1:]
s.insert(0, l)
j = n - 1
ans = 0
val = sum(s)
while val > k:
	val -= s[j]
	ans += 1
	j -= 1
print(ans)


(n, a, b) = 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)


(n, a, b) = map(int, input().split())
l = list(map(int, input().split()))
first = l[0]
l.pop(0)
l.sort()
s = sum(l) + first
i = 0
ans = first * a / s
cnt = 0
while ans < b:
	s = s - l.pop()
	ans = first * a / s
	i += 1
	cnt += 1
print(cnt)


import math
(n, a, b) = map(int, input().split())
c = list(map(int, input().split()))
val = math.floor(c[0] * a / b - c[0])
moves = 0
if c[0] * a / sum(c) >= b:
	print(0)
else:
	c.pop(0)
	c.sort()
	s = sum(c)
	while s > val and len(c) != 0:
		s -= c.pop()
		moves += 1
	print(moves)


(n, A, B) = tuple(map(int, input().split()))
s = list(map(int, input().split()))
diff = sum(s) - s[0] * A / B
s.pop(0)
s.sort()
count = 0
summa = 0
for i in range(1, len(s) + 1):
	if diff <= 0:
		break
	else:
		summa += s[-i]
		count += 1
		if summa >= diff:
			break
print(count)


import bisect

def howmanytodrop(n, A, B, first, rest):
	rest = list(reversed(sorted(rest)))
	thresholds = [0]
	count = 0
	for item in rest:
		count += item
		thresholds.append(count)
	target = sum(rest) + first - A * first / B
	return bisect.bisect_left(thresholds, target)
(n, A, B) = map(int, input().split())
l = [int(x) for x in input().split()]
first = l[0]
rest = l[1:]
print(howmanytodrop(n, A, B, first, rest))


import sys
import math
import bisect
from math import ceil

def input():
	return sys.stdin.readline().strip()

def iinput():
	return int(input())

def rinput():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))
mod = int(1000000000.0) + 7
(n, a, b) = rinput()
s = get_list()
si = s.pop(0)
S = si * a / b
s.sort(reverse=True)
cnt = 0
su = sum(s) + si
i = 0
while i < n and su > S:
	su -= s[i]
	cnt += 1
	i += 1
print(cnt)


(n, a, b) = map(int, input().split())
if n == 1:
	print('0')
	exit()
l = list(map(int, input().split()))
s = sum(l)
z = sorted(l[1:], reverse=True)
for i in range(n - 1):
	if l[0] * a / s >= b:
		print(i)
		exit()
	s -= z[i]
print(i + 1)


from sys import stdin, exit

def main():
	input = stdin.readline
	(n, A, B) = map(int, input().split())
	tab = [int(i) for i in input().split()]
	num = tab[0] * A
	S = sum(tab)
	del tab[0]
	tab.sort()
	tab.reverse()
	nbR = 0
	while num / S < B:
		S -= tab[nbR]
		nbR += 1
	print(nbR)
main()


Input = lambda : map(int, input().split())
(n, A, B) = Input()
s = list(Input())
SUM = sum(s)
First = s.pop(0)
s = sorted(s, reverse=True)
Ans = 0
while True:
	if A * First / SUM >= B:
		print(Ans)
		break
	SUM -= s[Ans]
	Ans += 1


(n, a, b) = map(int, input().split())
arr = list(map(int, input().strip().split()))
minVol = arr[0] * a / b
remainingHoles = sorted(arr[1:], reverse=True)
total = sum(arr)
k = 0
while total > minVol and k <= n - 2:
	total -= remainingHoles[k]
	k += 1
answer = k
print(answer)


(n, A, B) = list(map(int, input().split()))
C = list(map(int, input().split()))
s = C[0]
C = C[1:]
C.sort(reverse=True)
S = sum(C) + s
for i in range(0, n):
	if B <= s * A / S:
		print(i)
		break
	S -= C[i]


import math
(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
e = s.pop(0)
s.sort(reverse=True)
S = e + sum(s)
for i in range(n - 1):
	if e * a / S < b:
		S -= s[0]
		del s[0]
	else:
		print(i)
		break
else:
	print(n - 1)


(n, A, B) = map(int, input().split())
s = input().split()
S = 0
for i in range(n):
	s[i] = int(s[i])
	S += s[i]
t = s[0]
s.remove(t)
s.sort()
i = n - 2
while A * t / S < B:
	S -= s[i]
	i -= 1
print(max(n - 2 - i, 0))


(n, a, b) = map(int, input().split())
z = list(map(int, input().split()))
first = z[0]
s = sum(z)
del z[0]
z.sort()
i = n - 2
while first * a / s < b:
	s -= z[i]
	i -= 1
print(n - i - 2)


line0 = list(map(int, input().split()))
S = list(map(int, input().split()))
(n, v_total, v_need) = (line0[0], line0[1], line0[2])
S_others = S[1:]
S_others.sort()
S0 = S[0]
count = 0
S_others_intotal = sum(S_others)
percent = S[0] / (S[0] + S_others_intotal)
while percent < v_need / v_total:
	count += 1
	S_others_intotal = S_others_intotal - S_others[-1]
	S_others.pop()
	percent = S[0] / (S[0] + S_others_intotal)
print(count)


numbers = list(map(int, input().split()))
n = numbers[0]
A = numbers[1]
B = numbers[2]
arr = list(map(int, input().split()))
new_arr = arr[1:n]
new_arr.sort(reverse=True)
Sum = 0
for x in arr:
	Sum += x
p = A * arr[0] / B
cnt = 0
for i in range(n - 1):
	if p >= Sum:
		break
	else:
		Sum -= new_arr[i]
		cnt += 1
print(cnt)


(n, a, b) = map(int, input().split())
arr = list(map(int, input().split()))
si = arr.pop(0)
arr.sort(reverse=True)
tjog = sum(arr) + si
jog = 0
if si * a / tjog >= b:
	print(0)
else:
	for i in range(n - 1):
		jog += arr[i]
		if si * a / (tjog - jog) >= b:
			break
	print(i + 1)


(n, A, B) = map(int, input().split())
a = list(map(int, input().split()))
q = a[0]
a = sorted(a[1:], reverse=True)
s = sum(a) + q
i = 0
while i < n - 1 and q * A / s < B:
	s -= a[i]
	i += 1
print(i)


(n, A, B) = map(int, input().split())
s = list(map(int, input().split()))
ss = sum(s)
s1 = s[0]
sl = s[1:]
sl.sort()
num = 0
while s1 * A / ss < B:
	ss -= sl.pop()
	num += 1
print(num)


i = input().split(' ')
n = int(i[0])
a = int(i[1])
b = int(i[2])
i = input().split(' ')
arr = list(map(int, i))
q = arr[0]
arr = sorted(arr[1:], reverse=True)
s = sum(arr) + q
i = 0
while i < n - 1 and q * a / s < b:
	s -= arr[i]
	i += 1
print(i)


def main():
	[n, A, B] = [int(_) for _ in input().split()]
	holes = [int(_) for _ in input().split()]
	sum_holes = sum(holes)
	other_holes = holes[1:]
	other_holes.sort(reverse=True)
	max_sum_holes = holes[0] * A / B
	index = 0
	while sum_holes > max_sum_holes and index < n - 1:
		sum_holes -= other_holes[index]
		index += 1
	print(index)
main()


(n, A, B) = map(int, input().split())
(g, *s) = map(int, input().split())
s = (0, *sorted(s, reverse=True))
(g, sm) = (g * A, sum(s) + g)
for i in range(n):
	sm -= s[i]
	if g / sm >= B:
		print(i)
		break


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
ns = list(s[1:])
ns.sort(reverse=True)
ns = [s[0]] + ns
c = 0
i = 1
z = sum(ns)
while 1:
	x = s[0] * a / z
	if x >= b:
		print(c)
		break
	else:
		z = z - ns[i]
		c += 1
	i += 1


import math
(n, A, B) = map(int, input().split())
H = list(map(int, input().split()))
first = H.pop(0)
H.sort(reverse=True)
total = sum(H) + first
rate = first * A // total
if rate >= B:
	print(0)
else:
	for i in range(0, n - 1):
		total -= H[i]
		if math.floor(first * A / total) >= B:
			print(i + 1)
			break
	else:
		print(n - 1)


(n, A, B) = map(int, input().split())
s = list(map(int, input().split()))
S = sum(s)
q = sorted(s[1:], reverse=True)
q = s[:1] + q
k = int(s[0] * A // B)
c = 0
for i in range(1, n):
	if S <= k:
		break
	else:
		S -= q[i]
		c += 1
print(c)


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
x1 = s[0]
s = s[1:]
ans = 0
cur = sum(s) + x1
s.sort()
i = len(s) - 1
while True:
	if x1 * a >= cur * b:
		print(ans)
		break
	cur -= s[i]
	i -= 1
	ans += 1


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


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


(n, a, b) = map(int, input().split())
s = [int(i) for i in input().split()]
y = s[0]
s = s[1:]
s.sort()
m = [y]
for i in s:
	m.append(m[-1] + i)
for i in range(n):
	if b * m[-1 - i] <= a * m[0]:
		print(i)
		break


(n, A, B) = map(int, input().split())
l = list(map(int, input().split()))
S = l[0] * A // B
summ = sum(l)
summ = summ - S
l = l[1:]
l = sorted(l, reverse=True)
temp = 0
i = 0
while temp < summ:
	temp += l[i]
	i += 1
print(i)


(n, a, b) = map(int, input().split())
si = list(map(int, input().split()))
if a == b:
	print(n - 1)
else:
	num = si[0]
	summ = sum(si)
	a = b / a
	if num / summ >= a:
		print(0)
	else:
		si.sort()
		i2 = 0
		i = n - 1
		while i > -1:
			if i2 == 0 and si[i] == num:
				i2 = 1
				i -= 1
				continue
			summ -= si[i]
			if num / summ >= a:
				print(n - i - i2)
				break
			i -= 1


(N, A, B) = map(int, input().split())
S = list(map(int, input().split()))
si = S[0]
curS = sum(S)
S = sorted(S[1:])
ans = 0
while S != []:
	if A * si >= B * curS:
		break
	curS -= S.pop()
	ans += 1
print(ans)


a = input()
a = a.split(' ')
b = input()
b = b.split(' ')
for i in range(len(a)):
	a[i] = int(a[i])
for i in range(len(b)):
	b[i] = int(b[i])

def reska():
	x = 0
	for i in range(len(b)):
		x += b[i]
	y = 0
	if a[1] * (b[0] / x) >= a[2]:
		print(0)
		return
	c = b[1:]
	c = sorted(c)
	for i in range(len(c) - 1, -1, -1):
		y += 1
		x -= c[i]
		if a[1] * (b[0] / x) >= a[2]:
			print(y)
			return
reska()


import sys
import math
mod = 1000000007

def nospace(l):
	ans = ''.join((str(i) for i in l))
	return ans
(n, a, b) = map(int, sys.stdin.readline().split(' '))
s = list(map(int, sys.stdin.readline().split(' ')))
val = math.ceil(sum(s) - s[0] * a / b)
del s[0]
s.sort()
s = s[::-1]
count = 0
sm = 0
for ss in s:
	count += 1
	sm += ss
	if sm >= val:
		break
if val <= 0:
	count = 0
print(count)


(n, a, b) = map(int, input().split())
l = list(map(int, input().split()))
sum = 0
for i in range(n):
	sum += l[i]
v = l[0] * a / sum
cons = l[0] * a
c = 0
if v >= b:
	print(c)
else:
	l.pop(0)
	l.sort(reverse=True)
	while True:
		sum -= l[c]
		if cons / sum >= b:
			print(c + 1)
			break
		else:
			c += 1


import math
from sys import stdin, stdout

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

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

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

def I():
	return int(stdin.readline())

def main():
	(n, a, b) = In()
	l = L()
	if sum(l) <= int(l[0] * a / b):
		print(0)
	else:
		x = sum(l) - int(l[0] * a / b)
		l.remove(l[0])
		l = sorted(l, reverse=True)
		for i in range(n - 1):
			x -= l[i]
			if x <= 0:
				print(i + 1)
				break
main()


(n, r, b) = map(int, input().split())
a = list(map(int, input().split()))
k = a[0] * r // b
l = a[0]
a.remove(a[0])
a.sort()
s = l
c = 1
for i in range(len(a)):
	if s + a[i] <= k:
		s = s + a[i]
		c = c + 1
	else:
		break
print(n - c)


import copy
(n, a, b) = map(int, input().split(' '))
arr = list(map(int, input().split(' ')))
mx = sum(arr)
f = arr[0]
arr = sorted(arr[1:], reverse=True)
total = copy.copy(arr)
for i in range(1, n - 1):
	total[i] += total[i - 1]

def fn(i, j):
	if i == j:
		return i
	mid = i + (j - i) // 2
	flow = f * a / (mx - total[mid])
	if flow >= b and (mid == 0 or f * a / (mx - total[mid - 1]) < b):
		return mid
	if flow >= b and f * a / (mx - total[mid - 1]) >= b:
		return fn(i, mid)
	else:
		return fn(mid + 1, j)
print(0 if f * a / mx >= b else fn(0, n - 2) + 1)


(n, A, B) = list(map(int, input().split(' ')))
x = list(map(int, input().split(' ')))
(a, Sum, x, i) = (x[0], sum(x), list(sorted(x[1:], reverse=True)), 0)
while a * A / Sum < B:
	Sum = Sum - x[i]
	i += 1
print(i)


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
s = [s[0]] + list(sorted(s[1:]))
z = s[0] * a / b
sm = sum(s)
i = n - 1
while i > 0 and sm > z:
	sm -= s[i]
	i -= 1
print(n - i - 1)


(n, a, b) = map(int, input().split())
arr = list(map(int, input().split()))
sm = sum(arr)
cnt = 0
first = arr.pop(0)
arr.sort()
while first * a / sm < b:
	cnt += 1
	sm -= arr.pop()
print(cnt)


(n, a, b) = map(int, input().split())
l = list(map(int, input().split()))
s = sum(l)
if l[0] * a / b >= s:
	print(0)
else:
	(x, c) = (l[0] * a / b, 0)
	l = l[1:]
	l.sort()
	for i in range(n - 2, -1, -1):
		s -= l[i]
		c += 1
		if s <= x:
			print(c)
			break


(n, a, b) = map(int, input().split())
arr = list(map(int, input().split()))
exp = arr[0]
total_s = sum(arr)
arr = arr[1:n]
arr.sort(reverse=True)
if a == b:
	print(n - 1)
else:
	ans = 0
	k = 0
	while a * exp // total_s < b:
		ans += 1
		total_s -= arr[k]
		k += 1
	print(ans)


(n, a, b) = list(map(int, input().split()))
s = list(map(int, input().split()))
ssr = sorted(s, reverse=True)
for i in range(n - 1):
	if ssr[i] == s[0]:
		ssr = ssr[:i] + ssr[i + 1:]
		break
summ = 0
for i in s:
	summ += i
for i in range(n):
	if s[0] * a / summ >= b:
		print(i)
		exit()
	else:
		summ -= ssr[i]


from itertools import accumulate
from operator import add
(n, A, B) = [int(i) for i in input().split(' ')]
s = [int(i) for i in input().split(' ')]

def gao():
	if n == 1:
		return 0
	first = s[0]
	a = [0] + sorted(s[1:])
	sum = list(accumulate(a, add))
	(l, r) = (0, n - 1)
	ans = -1
	while l <= r:
		mid = (l + r) // 2
		if first * A >= (first + sum[mid]) * B:
			ans = mid
			l = mid + 1
		else:
			r = mid - 1
	return n - 1 - ans
print(gao())


(n, A, B) = [int(x) for x in input().split(' ')]
s = [int(x) for x in input().split(' ')]
S = sum(s)
a = s[0]
q = sorted(s[1:])
c = 0
while a * A / S < B:
	S -= q.pop()
	c += 1
print(c)


(holes, water_have, water_plant) = map(int, input().split())
hole_ratio = list(map(int, input().split()))
plant_A = hole_ratio[0]
hole_ratio = hole_ratio[1:]
hole_ratio.sort()
hole_ratio.reverse()
blocked = 0
sum_non_blocked = sum(hole_ratio) + plant_A
for each in hole_ratio:
	if water_have * plant_A / sum_non_blocked >= water_plant:
		break
	sum_non_blocked -= each
	blocked += 1
print(blocked)


rd = lambda : map(int, input().split())
(n, a, b) = rd()
(l, *m) = list(rd())
m.sort()
x = l * a / b - l
for y in m:
	x -= y
	if x < 0:
		break
	n -= 1
print(n - 1)


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


import sys
import math
import bisect
import itertools
import random

def main():
	(n, x, y) = map(int, input().split())
	A = list(map(int, input().split()))
	A = A[0:1] + sorted(A[1:])
	for i in range(1, n):
		A[i] += A[i - 1]
	tmp = A[0] * x / y
	first = 0
	last = bisect.bisect_right(A, tmp)
	print(n - (last - first))
main()


R = lambda : map(int, input().split())
(n, A, B) = R()
s = list(R())
t = s[0]
s0 = sum(s)
s = sorted(s[1:])
x = t * A / B
res = len(s)
i = 0
while s0 > x:
	s0 -= s[res - i - 1]
	i += 1
print(i)


(n, a, b) = map(int, input().split())
l = list(map(int, input().split()))
sum_ = sum(l)
s0 = l.pop(0)
ans = 0
i = 0
l.sort(reverse=True)
while i < n - 1 and s0 * a / sum_ < b:
	ans += 1
	sum_ -= l[i]
	i += 1
print(ans)


(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) = map(int, input().split())
s = list(map(int, input().split()))
first = s[0]
s = s[1:]
s.sort(reverse=True)
sum_ = sum(s) + first
i = 0
res = 0
while A * first / sum_ < B:
	sum_ -= s[i]
	res += 1
	i += 1
print(res)


(n, a, b) = map(int, input().split(' '))
s = list(map(int, input().split(' ')))
s0 = s.pop(0)
sm = sum(s) + s0
s.sort(reverse=True)
if a * s0 / sm >= b:
	print(0)
else:
	for i in range(n - 1):
		sm -= s.pop(0)
		if a * s0 / sm >= b:
			print(i + 1)
			break


(N, A, B) = map(int, input().split())
(fi, *src) = list(map(int, input().split()))
w = sum(src) + fi
if w * B <= fi * A:
	print(0)
	exit()
src.sort()
ans = 1
while src:
	w -= src.pop()
	if w * B <= fi * A:
		print(ans)
		exit()
	ans += 1


def solve():
	(n, A, B) = map(int, input().split())
	S = list(map(int, input().split()))
	S2 = S[1:]
	S2.sort()
	M = sum(S)
	count = 0
	for s in reversed(S2):
		if M <= S[0] * A / B:
			print(count)
			return
		M -= s
		count += 1
	print(count)
solve()


if_debag = False
input_texts = '4 80 20\n3 2 1 4\n'
input_texts = input_texts.split('\n')
it = iter(input_texts)

def my_input():
	if if_debag:
		return next(it)
	else:
		return input()
(n, A, B) = my_input().split()
n = int(n)
A = int(A)
B = int(B)
ss0 = [int(s) for s in my_input().split()]
ss1 = sorted(ss0[1:], key=lambda s: s, reverse=False)

def ss(i):
	if i == 0:
		return ss0[0]
	else:
		return ss1[i - 1]
ssss = 0
sss = []
for i in range(n):
	ssss += ss(i)
	sss.append(ssss)
ans = 0
for i in range(n):
	flow = ss0[0] * A / sss[n - i - 1]
	if flow >= B:
		ans = i
		break
	ans + -1
print(ans)


(n, a, b) = list(map(int, input().split()))
s = list(map(int, input().split()))
summ = sum(s)
first = s[0]
s.pop(0)
s.sort(reverse=True)
ans = 0
for i in range(len(s)):
	if first * a // summ >= b:
		break
	summ -= s[i]
	ans += 1
print(ans)


(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
s1 = s[1:]
s1.sort()
x = sum(s)
while a * s[0] < b * x:
	x -= s1.pop()
print(n - len(s1) - 1)


(n, a, b) = map(int, input().split())
l = list(map(int, input().split()))
first = l[0]
l1 = l[1:]
l1.sort()
c = 0
summ = sum(l)
while first * a / summ < b:
	summ = summ - l1.pop()
	c += 1
print(c)


from __future__ import division, print_function
import os, sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().strip().split(' '))

def msi():
	return map(str, input().strip().split(' '))

def li():
	return list(mi())

def dmain():
	sys.setrecursionlimit(1000000)
	threading.stack_size(1024000)
	thread = threading.Thread(target=main)
	thread.start()
import sys
input = sys.stdin.readline
scanner = lambda : int(input())
string = lambda : input().rstrip()
get_list = lambda : list(read())
read = lambda : map(int, input().split())
get_float = lambda : map(float, input().split())

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def lcm(a, b):
	return a * b // math.gcd(a, b)

def is_integer(n):
	return math.ceil(n) == math.floor(n)

def nCr(n, k):
	if k > n:
		return 0
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	(prime[0], prime[1]) = (False, False)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def phi(n):
	result = n
	p = 2
	while p * p <= n:
		if n % p == 0:
			while n % p == 0:
				n = n // p
			result = result * (1.0 - 1.0 / float(p))
		p = p + 1
	if n > 1:
		result = result * (1.0 - 1.0 / float(n))
	return int(result)

def is_prime(n):
	if n == 0:
		return False
	if n == 1:
		return True
	for i in range(2, int(n ** (1 / 2)) + 1):
		if not n % i:
			return False
	return True

def next_prime(n, primes):
	while primes[n] != True:
		n += 1
	return n
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

def factors(n):
	res = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			res.append(i)
			res.append(n // i)
	return list(set(res))

def int_array():
	return list(map(int, input().strip().split()))

def float_array():
	return list(map(float, input().strip().split()))

def str_array():
	return input().strip().split()

def binary_search(low, high, w, h, n):
	while low < high:
		mid = low + (high - low) // 2
		if check(mid, w, h, n):
			low = mid + 1
		else:
			high = mid
	return low

def check(beauty, s, n, count):
	pass
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
alphs = 'abcdefghijklmnopqrstuvwxyz'
from itertools import permutations
import math
import bisect as bis
import random
import sys
import collections as collect

def solve():
	(n, A, B) = read()
	(first, *sizes) = map(int, input().split())
	sizes.sort(reverse=True)
	summ = 0
	S = sum(sizes) + first
	c = 0
	for s in sizes:
		val = first * A / S
		if val >= float(B):
			break
		else:
			c += 1
			S -= s
	print(c)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
for i in range(1):
	solve()


import math
(n, a, b) = map(int, input().split())
s = list(map(int, input().split()))
c = 0
y = s[0]
su = sum(s)
s.remove(s[0])
i = 0
s.sort(reverse=True)
while a * y / su < b:
	su -= s[i]
	i += 1
	c += 1
print(c)


(n, a, b) = map(int, input().split(' '))
holes = [int(i) for i in input().split(' ')]
first_hole = holes[0]
sum_size = sum(holes)
del holes[0]
holes = sorted(holes)[::-1]
s = 0
while first_hole * a / sum_size < b:
	sum_size -= holes[s]
	s += 1
print(s)


(n, a, b) = map(int, input().split())
ar = input().split(' ')
ar = [int(i) for i in ar]
s = sum(ar)
first = ar.pop(0)
ar = sorted(ar)
i = 1
blocked = 0
while first * a / s < b:
	s -= ar[-i]
	i += 1
	blocked += 1
print(blocked)


(n, A, B) = map(int, input().split())
(x, *holes) = map(int, input().split())
S = x + sum(holes)
holes.sort(reverse=True)
for i in range(n):
	if x * A >= B * S:
		break
	else:
		S -= holes[i]
print(i)