You are policeman and you are playing a game with Slavik. The game is turn-based and each turn consists of two phases. During the first phase you make your move and during the second phase Slavik makes his move.

There are $n$ doors, the $i$-th door initially has durability equal to $a_i$.

During your move you can try to break one of the doors. If you choose door $i$ and its current durability is $b_i$ then you reduce its durability to $max(0, b_i - x)$ (the value $x$ is given).

During Slavik's move he tries to repair one of the doors. If he chooses door $i$ and its current durability is $b_i$ then he increases its durability to $b_i + y$ (the value $y$ is given). Slavik cannot repair doors with current durability equal to $0$.

The game lasts $10^{100}$ turns. If some player cannot make his move then he has to skip it.

Your goal is to maximize the number of doors with durability equal to $0$ at the end of the game. You can assume that Slavik wants to minimize the number of such doors. What is the number of such doors in the end if you both play optimally?


-----Input-----

The first line of the input contains three integers $n$, $x$ and $y$ ($1 \le n \le 100$, $1 \le x, y \le 10^5$) — the number of doors, value $x$ and value $y$, respectively.

The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^5$), where $a_i$ is the initial durability of the $i$-th door.


-----Output-----

Print one integer — the number of doors with durability equal to $0$ at the end of the game, if you and Slavik both play optimally.


-----Examples-----
Input
6 3 2
2 3 1 3 4 2

Output
6

Input
5 3 3
1 2 4 2 3

Output
2

Input
5 5 6
1 2 6 10 3

Output
2



-----Note-----

Clarifications about the optimal strategy will be ignored.

Source: codeforces | Difficulty: EASY
Tags: Game theory


Solutions:
from sys import stdin, stdout
from sys import maxsize
input = stdin.readline

def solve():
	pass
test = 1
for t in range(0, test):
	(n, x, y) = list(map(int, input().strip().split()))
	a = [int(x) for x in input().strip().split()]
	if x > y:
		print(n)
	else:
		lessx = 0
		morey = 0
		for el in a:
			if el <= x:
				lessx += 1
				if el + y > x:
					morey += 1
		print(morey // 2 + morey % 2 + lessx - morey)
	ans = solve()


(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
if x > y:
	print(n)
b = [i for i in a if i <= x]
if x == y:
	print(len(b) // 2 + len(b) % 2)
if x < y:
	print(len(b) // 2 + len(b) % 2)


t = list(map(int, input().split(' ')))
n = t[0]
x = t[1]
y = t[2]
t = list(map(int, input().split(' ')))
if x > y:
	print(n)
else:
	s = []
	for i in range(n):
		if t[i] <= x:
			s.append(t[i])
	if len(s) % 2 != 0:
		print(len(s) // 2 + 1)
	else:
		print(len(s) // 2)


inp = input().split()
(n, x, y) = (int(inp[0]), int(inp[1]), int(inp[2]))
inp = input().split()
if x > y:
	print(n)
else:
	count = 0
	for i in inp:
		if int(i) <= x:
			count += 1
	print((count + 1) // 2)


import sys
(N, x, y) = map(int, input().split())
A = [int(i) for i in input().split()]
if x > y:
	print(N)
	sys.exit()
num = 0
for a in A:
	if a <= x:
		num += 1
if num % 2 == 1:
	print(num // 2 + 1)
else:
	print(num // 2)


(n, x, y) = map(int, input().split())
A = list(map(int, input().split()))
ans = 0
if x > y:
	ans = n
elif x <= y:
	a = 0
	for i in A:
		if i <= x:
			a += 1
	if a % 2 == 0:
		ans = a // 2
	else:
		ans = a // 2 + 1
print(ans)


(n, x, y) = (int(d) for d in input().split())
a = [int(d) for d in input().split()]
if x - y <= 0:
	res = ([a[i] <= x for i in range(n)].count(True) + 1) // 2
else:
	res = n
print(res)


(n, x, y) = map(int, input().split())
a = [*map(int, input().split())]
a = sorted(a)
if x > y:
	print(len(a))
else:
	nm = 0
	for i in a:
		if i <= x:
			nm += 1
		else:
			break
	print((nm + 1) // 2)


(n, x, y) = map(int, input().split())
l1 = list(map(int, input().split()))
count1 = 0
count2 = 0
for item in l1:
	if item <= x:
		count1 += 1
		if item + y > x:
			count2 += 1
if x > y:
	print(n)
elif x == y:
	if count1 % 2 == 0:
		print(count1 // 2)
	else:
		print(count1 // 2 + 1)
else:
	total = 0
	if count2 % 2 == 0:
		total += count2 // 2
	else:
		total += count2 // 2 + 1
	print(total + (count1 - count2))


from math import ceil
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	a.sort()
	ct = 0
	for i in range(n):
		if a[i] <= x:
			ct += 1
	print(int(ceil(ct / 2)))


(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
if x > y:
	print(n)
else:
	count = 0
	ans = 0
	for i in range(n):
		if x >= arr[i]:
			count += 1
	if count % 2 == 1:
		ans += 1
	ans += count // 2
	print(ans)


(a, b, c) = map(int, input().split())
l = list(map(int, input().split()))
if b > c:
	print(a)
else:
	t = 0
	for i in l:
		if i <= b:
			t += 1
	print((t + 1) // 2)


(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
import math
if x > y:
	print(n)
else:
	count = 0
	for i in range(n):
		if a[i] <= x:
			count += 1
	print(int(math.ceil(count / 2)))


import math
nxy = input().split(' ')
n = int(nxy[0])
x = int(nxy[1])
y = int(nxy[2])
arr = list(map(int, input().split(' ')))
if x > y:
	print(n)
else:
	ans = 0
	for i in range(len(arr)):
		if arr[i] <= x:
			ans += 1
	fans = ans // 2
	if ans % 2 == 1:
		fans += 1
	print(fans)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	c = 0
	from math import ceil
	for i in a:
		if i <= x:
			c += 1
	print(ceil(c / 2))


(n, x, y) = map(int, input().split())
ls = sorted(list(map(int, input().split())))
c = 0
for i in range(n):
	if ls[i] <= x:
		c += 1
if x > y:
	print(n)
else:
	print(c // 2 + c % 2)


from collections import Counter
(n, x, y) = map(int, input().split())
a = map(int, input().split())
if x > y:
	print(n)
else:
	print((sum(map(lambda t: t <= x, a)) + 1) // 2)


import sys
input = sys.stdin.readline
(n, x, y) = map(int, input().split())
A = list(map(int, input().split()))
if x > y:
	print(n)
else:
	count = 0
	for a in A:
		if a <= x:
			count += 1
	print((count + 1) // 2)


(n, x, y) = map(int, input().split())
a = [int(o) for o in input().split()]
if x > y:
	exit(print(n))
c = 0
for i in range(n):
	if a[i] <= x:
		c += 1
ans = c // 2
if c % 2 == 1:
	ans += 1
print(ans)


line = input().split(' ')
n = int(line[0])
x = int(line[1])
y = int(line[2])
_ = []
line = input().split(' ')
for a in line:
	_.append(int(a))
_.sort()

def solved():
	count = 0
	if x < y:
		turn = True
		for a in _:
			if a <= x and turn:
				count += 1
			turn = not turn
		return count
	elif x == y:
		teamX = 0
		teamY = 0
		turn = True
		for a in range(0, _.__len__()):
			if _[a] <= x:
				teamX += 1
			else:
				teamY += 1
		extra = 0
		if teamX % 2 == 0:
			count += int(teamX / 2)
		else:
			count += int((teamX - 1) / 2) + 1
		return count
	else:
		return n
print(solved())


(n, x, y) = map(int, input().split())
s = list(map(int, input().split()))
if x > y:
	print(n)
else:
	print((sum(map(lambda _: 1 if _ <= x else 0, s)) + 1) // 2)


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

def main():
	(n, x, y) = readline()
	doors = readline()
	if x > y:
		print(sum((1 for __ in doors)))
	else:
		one_punch_count = sum((1 for door in doors if door <= x))
		print(one_punch_count + 1 >> 1)
main()


from sys import stdin, stdout
from math import gcd, ceil, sqrt
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
mod = 1000000007
(n, x, y) = iia()
arr = iia()
if x > y:
	print(n)
else:
	count = 0
	for i in arr:
		if i <= x:
			count += 1
	print(ceil(count / 2))


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
c = 0
for i in range(len(l)):
	if l[i] <= x:
		c += 1
if x > y:
	print(len(l))
elif c % 2 == 0:
	d = int(c / 2)
	print(d)
else:
	d = int(c / 2) + 1
	print(d)


inp = input().split()
n = int(inp[0])
x = int(inp[1])
y = int(inp[2])
inp = input().split()
a = list()
for i in range(n):
	a.append(int(inp[i]))
if x <= y:
	a.sort()
	i = 0
	while i != n - 1:
		if a[i] - x >= 0:
			a[i] = a[i] - x
		else:
			a[i] = 0
		if a[i] > 0:
			a[i] = a[i] + y
		else:
			a[i + 1] = a[i + 1] + y
		i += 1
	if a[n - 1] - x >= 0:
		a[n - 1] = a[n - 1] - x
	else:
		a[n - 1] = 0
	if a[n - 1] > 0:
		a[n - 1] = a[n - 1] + y
	ans = 0
	for i in range(n):
		if a[i] == 0:
			ans = ans + 1
	print(ans)
else:
	print(n)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	c = 0
	for i in a:
		if i <= x:
			c += 1
	print(c - c // 2)


(i_drzwi, atak, leczenie) = map(int, input().split())
drzwi = sorted(list(map(int, input().split())))
if atak > leczenie:
	print(i_drzwi)
else:
	i_zniszcze = 0
	for x in drzwi:
		if x <= atak:
			i_zniszcze += 1
		else:
			break
	print(i_zniszcze - i_zniszcze // 2)


(n, x, y) = map(int, input().split())
a = list((int(x) for x in input().split()))
if x > y:
	print(n)
elif x <= y:
	res = 0
	b = []
	for i in a:
		if i <= x:
			b.append(i)
	while len(b) > 0:
		b.sort()
		b.pop()
		res += 1
		if len(b) == 0:
			break
		if b[len(b) - 1] + y > x:
			b.pop()
	print(res)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
cnt = 0
for i in range(n):
	cur = a[i]
	if cur <= x:
		cnt += 1
if x > y:
	print(n)
else:
	print((cnt + 1) // 2)


MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
(n, x, y) = I()
l = I()
if x > y:
	print(n)
	exit(0)
diff = y - x
l.sort()
ans = 0
if l[0] <= x:
	ans += 1
c = y
for i in range(1, n):
	if l[i] <= x:
		if l[i] + c <= x:
			ans += 1
			c += y
		else:
			c -= y
print(ans)


def doors(lst, x, y):
	count = 0
	for elem in lst:
		if elem <= x:
			count += 1
	if x > y:
		return len(lst)
	return (count + 1) // 2
(N, x, y) = [int(i) for i in input().split()]
a = [int(j) for j in input().split()]
print(doors(a, x, y))


R = lambda : map(int, input().split())
(n, x, y) = R()
print(((sum((u <= x for u in R())) + 1) // 2, n)[x > y])


from sys import stdin

def main():
	(n, d, r) = [int(x) for x in stdin.readline().strip().split(' ')]
	arr = [int(x) for x in stdin.readline().strip().split(' ')]
	if d > r:
		print(len(arr))
	else:
		cont = 0
		for x in arr:
			if x - d <= 0:
				cont = cont + 1
		res = cont // 2 if cont % 2 == 0 else cont // 2 + 1
		print(res)
main()


def mi():
	return map(int, input().split())
(n, x, y) = mi()
a = list(mi())
from math import ceil
le = 0
for i in a:
	if i <= x:
		le += 1
if y >= x:
	print(ceil(le / 2))
else:
	print(n)


import random

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

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

def li():
	return list(mi())
(n, x, y) = tuple(mi())
a = li()
random.shuffle(a)
a = sorted(a)
c1 = 0
c2 = 0
for i in a:
	if i <= x:
		c1 += 1
	if i <= y:
		c2 += 1
ans = 0
if x <= y:
	ans = (c1 + 1) // 2
else:
	ans = n
print(ans)


import re, math, decimal, bisect

def read():
	return input().strip()

def iread():
	return int(input().strip())

def viread():
	return [int(_) for _ in input().strip().split()]
(n, x, y) = viread()
b = sorted(viread())
if x > y:
	print(n)
else:
	c = len([bi for bi in b if bi <= x])
	print(int(c / 2 + 0.9))


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
if x > y:
	print(n)
else:
	s = sum((i <= x for i in l))
	print((s + 1) // 2)


from math import ceil
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
	exit()
cnt = 0
for i in a:
	if i <= x:
		cnt += 1
print(ceil(cnt / 2))


(n, x, y) = map(int, input().split())
a = [int(d) for d in input().split()]
if x > y:
	print(n)
else:
	vypilivaemye = 0
	for d in a:
		if d <= x:
			vypilivaemye += 1
	print((vypilivaemye + 1) // 2)


def main():
	(n, x, y) = map(int, input().split())
	a = list(map(int, input().split()))
	if x > y:
		print(n)
	else:
		relevant = [d for d in a if d <= x]
		num = len(relevant)
		print(num // 2 + num % 2)
main()


import sys
import math
import collections
import operator as op
from collections import deque
from math import gcd, inf, sqrt
from bisect import bisect_right, bisect_left
from functools import reduce
from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(2 ** 20)

def factorial(n):
	if n == 0:
		return 1
	return n * factorial(n - 1)

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom

def prime_factors(n):
	i = 2
	factors = []
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.append(i)
	if n > 1:
		factors.append(n)
	return len(set(factors))

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def factors(n):
	return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))
MOD = 10 ** 9 + 7
T = 1
for _ in range(T):
	(n, x, y) = list(map(int, stdin.readline().split()))
	a = list(map(int, stdin.readline().split()))
	c = 0
	a.sort()
	if x > y:
		print(n)
		continue
	ans = 0
	for i in range(n):
		if a[i] <= x:
			ans += 1
	print((ans + 1) // 2)


(n, x, y) = map(int, input().split())
ar = list(map(int, input().split()))
if x <= y:
	f = 0
	for i in ar:
		if i <= x:
			f += 1
	if f % 2 == 1:
		f += 1
	print(f // 2)
if x > y:
	print(n)


import sys
import math
input = sys.stdin.readline

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
(n, a, b) = invr()
ara = inara()
if a > b:
	print(n)
else:
	ans = 1
	for num in ara:
		if num <= a:
			ans += 1
	print(ans // 2)


(n, m, k) = map(int, input().split())
t = list(map(int, input().split()))
if m > k:
	print(n)
else:
	t = list(filter(lambda x: x <= m, t))
	import math
	print(math.ceil(len(t) / 2))


(a, b, c) = map(int, input().split())
d = sorted(map(int, input().split()))
if b > c:
	print(a)
else:
	i = 0
	while i < a:
		if d[i] > b:
			break
		else:
			i += 1
	print((i + 1) // 2)


from math import ceil
(n, x, y) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
count = 0
if x > y:
	print(n)
else:
	a.sort()
	for i in range(n):
		if a[i] <= x:
			count += 1
	print(ceil(count / 2))


(n, x, y) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
a.sort()
if x > y:
	print(n)
else:
	count = 0
	for i in range(n):
		if a[i] <= x:
			count += 1
	print((count - 1) // 2 + 1)


(n, x, y) = list(map(int, input().split()))
b = list(map(int, input().split()))
b.sort()
if x > y:
	print(n)
else:
	k = sum([1 for i in b if i <= x])
	print((k + (k % 2 == 1)) // 2)


(n, x, y) = [int(x) for x in input().strip().split(' ')]
a = [int(x) for x in input().strip().split(' ')]
c = 0
if x > y:
	print(n)
else:
	for i in range(n):
		if a[i] <= x:
			c += 1
	print((c + 1) // 2)


from bisect import bisect_right as br
import math
(n, x, y) = map(int, input().split())
a = sorted(map(int, input().split()))
if x > y:
	print(n)
else:
	print(math.ceil(br(a, x) / 2))


import math
import bisect
import itertools
import sys
I = lambda : sys.stdin.readline()
mod = 10 ** 9 + 7

def mindiff(a):
	b = a[:]
	b.sort()
	m = 10000000000
	for i in range(len(b) - 1):
		if b[i + 1] - b[i] < m:
			m = b[i + 1] - b[i]
	return m

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

def merge(a, b):
	i = 0
	j = 0
	c = 0
	ans = []
	while i < len(a) and j < len(b):
		if a[i] < b[j]:
			ans.append(a[i])
			i += 1
		else:
			ans.append(b[j])
			c += len(a) - i
			j += 1
	ans += a[i:]
	ans += b[j:]
	return (ans, c)

def mergesort(a):
	if len(a) == 1:
		return (a, 0)
	mid = len(a) // 2
	(left, left_inversion) = mergesort(a[:mid])
	(right, right_inversion) = mergesort(a[mid:])
	(m, c) = merge(left, right)
	c += left_inversion + right_inversion
	return (m, c)

def is_prime(num):
	if num == 1:
		return False
	if num == 2:
		return True
	if num == 3:
		return True
	if num % 2 == 0:
		return False
	if num % 3 == 0:
		return False
	t = 5
	a = 2
	while t <= int(math.sqrt(num)):
		if num % t == 0:
			return False
		t += a
		a = 6 - a
	return True

def ceil(a, b):
	if a % b == 0:
		return a // b
	else:
		return a // b + 1

def binsearch(arr, b, low, high):
	if low == high:
		return low
	if arr[math.ceil((low + high) / 2)] < b:
		return binsearch(arr, b, low, math.ceil((low + high) / 2) - 1)
	else:
		return binsearch(arr, b, math.ceil((low + high) / 2), high)

def ncr1(n, r):
	s = 1
	for i in range(min(n - r, r)):
		s *= n - i
		s %= mod
		s *= pow(i + 1, mod - 2, mod)
		s %= mod
	return s

def calc(n, m, r):
	s = 0
	for i in range(0, r + 1, 2):
		s += ncr1(n, i) * ncr1(m, i)
		s %= mod
	return s
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	c = 0
	for i in a:
		if i <= x:
			c += 1
	print(ceil(c, 2))


from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353

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

def iinp():
	return int(inp())

def out(var, end='\n'):
	stdout.write(str(var) + '\n')

def outa(*var, end='\n'):
	stdout.write(' '.join(map(str, var)) + end)

def lmp():
	return list(mp())

def mp():
	return map(int, inp().split())

def smp():
	return map(str, inp().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(m, val) for j in range(n)]

def remadd(x, y):
	return 1 if x % y else 0

def ceil(a, b):
	return (a + b - 1) // b
S1 = 'abcdefghijklmnopqrstuvwxyz'
S2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

def isprime(x):
	if x <= 1:
		return False
	if x in (2, 3):
		return True
	if x % 2 == 0:
		return False
	for i in range(3, int(sqrt(x)) + 1, 2):
		if x % i == 0:
			return False
	return True
(n, x, y) = mp()
arr = lmp()
if x > y:
	print(n)
else:
	c = 0
	for i in arr:
		c += i <= x
	print(ceil(c, 2))


(n, x, y) = map(int, input().split())
A = [int(x) for x in input().split()]
if x <= y:
	print((len([a for a in A if a <= x]) + 1) // 2)
else:
	print(len(A))


(q, w, e) = map(int, input().split())
a = list(map(int, input().split()))
if w > e:
	print(q)
else:
	print((len(list(filter(lambda x: x <= w, a))) + 1) // 2)


from math import ceil
(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
if x > y:
	print(n)
else:
	count = 0
	for i in l:
		if i <= x:
			count += 1
	print(ceil(count / 2))


(n, m, k) = map(int, input().split())
d = list(map(int, input().split()))
sum = 0
for i in range(n):
	if d[i] <= m:
		sum += 1
if m > k:
	print(n)
else:
	print((sum + 1) // 2)


import math
(n, x, y) = map(int, input().split())
data = [int(x) for x in input().split()]
cnt = 0
for q in data:
	if q <= x:
		cnt += 1
if x > y:
	print(n)
else:
	print(math.ceil(cnt / 2))


from math import *
(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	s = len(list(filter(lambda i: i <= x, a)))
	print(ceil(s / 2))


import sys
(n, x, y) = map(int, input().split())
a = map(int, input().split())
if x > y:
	print(n)
	sys.exit()
if x <= y:
	weak = sum((val <= x for val in a))
	print((1 + weak) // 2)
	sys.exit()


import math
(n, x, y) = map(int, input().split())
a = [int(i) for i in input().split()]
if x > y:
	ans = n
else:
	c = 0
	for i in range(n):
		if a[i] <= x:
			c += 1
	ans = math.ceil(c / 2)
print(ans)


def insertion_sort(dur, s, n):
	for i in range(s, n - 1):
		if dur[i] > dur[i + 1]:
			temp = dur[i]
			dur[i] = dur[i + 1]
			dur[i + 1] = temp
		else:
			break
	return
lis1 = input().split(' ')
lis2 = input().split(' ')
n = int(lis1[0])
x = int(lis1[1])
y = int(lis1[2])
dur = []
for i in range(n):
	dur.append(int(lis2[i]))
if x > y:
	print(n)
else:
	broken = 0
	dur.sort()
	for i in range(n - 1):
		insertion_sort(dur, i, n)
		if dur[i] <= x:
			broken += 1
			dur[i + 1] += y
		else:
			break
	if dur[n - 1] <= x:
		broken += 1
	print(broken)


from sys import stdin
(n, x, y) = map(int, stdin.readline().split())
a = list(map(int, stdin.readline().strip().split()))
count = 0
if x > y:
	print(n)
else:
	for i in a:
		if i <= x:
			count += 1
	if count % 2 == 0:
		ans = count // 2
	else:
		ans = count // 2 + 1
	print(ans)


[n, x, y] = list(map(int, input().split()))
num = list(map(int, input().split()))
count = 0
if x > y:
	print(n)
else:
	for i in num:
		if i <= x:
			count += 1
	if count % 2 == 0:
		print(count // 2)
	else:
		print(count // 2 + 1)


(N, X, Y) = map(int, input().split())
a = list(map(int, input().split()))
if X > Y:
	print(N)
	exit()
breakable = len([None for n in a if n <= X])
print((breakable + 1) // 2)


(n, x, y) = map(int, input().split())
array = list(map(int, input().split()))
if x > y:
	print(n)
else:
	con = 0
	for e in array:
		if e <= x:
			con += 1
	print((con + 1) // 2)


for _ in range(1):
	(n, x, y) = map(int, input().split())
	a = list(map(int, input().split()))
	if x > y:
		print(n)
	else:
		c = 0
		for val in a:
			if val <= x:
				c += 1
		print((c + 1) // 2)


import sys
import math
(amount, x, y) = [int(s) for s in input().split()]
array = [int(s) for s in input().split()]
counter = 0
if x > y:
	print(amount)
	sys.exit(0)
else:
	for i in range(len(array)):
		if array[i] - x <= 0:
			counter += 1
print(math.ceil(counter / 2))


import math
(n, x, y) = map(int, input().split())
v = [int(i) for i in input().split()]
mi = 0
ma = 0
for i in range(n):
	if v[i] <= x:
		mi += 1
	else:
		ma += 1
if x <= y:
	print(math.ceil(mi / 2))
else:
	print(n)


def main():
	arr = input().split()
	n = int(arr[0])
	x = int(arr[1])
	y = int(arr[2])
	if x <= y:
		arr = input().split()
		count = 0
		for a in range(n):
			test = int(arr[a])
			if test <= x:
				count += 1
		if count % 2 == 1:
			print(count // 2 + 1)
		else:
			print(count // 2)
	else:
		print(n)
main()


import math
(n, x, y) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
if x > y:
	print(str(len(a)))
else:
	c = 0
	for t in a:
		if t <= x:
			c = c + 1
	res = math.ceil(c / 2)
	print(res)


from bisect import bisect_right
(n, x, y) = map(int, input().split())
line = sorted(list(map(int, input().split())))
if x > y:
	print(n)
else:
	k = bisect_right(line, x)
	print(k // 2 + k % 2)


import sys
import math
sys.setrecursionlimit(10 ** 9)
(n, x, y) = map(int, sys.stdin.readline().split())
porte = list(map(int, sys.stdin.readline().split()))
if x <= y:
	porte.sort()
	total = 0
	if porte[0] - x <= 0:
		total = 1
		porte.pop(0)
	for i in range(n - 1):
		mini = 10 ** 6
		m = 0
		for a in range(len(porte)):
			if porte[a] < mini:
				m = a
				mini = porte[a]
		porte[m] += y
		toget = -1
		for a in range(len(porte)):
			if porte[a] - x <= 0:
				toget = a
		if toget != -1:
			total += 1
			porte.pop(toget)
	print(total)
if x > y:
	porte.sort()
	total = n
	print(total)


import bisect

def main():
	(n, x, y) = map(int, input().split())
	a = list(map(int, input().split()))
	if x > y:
		print(len(a))
	elif x <= y:
		a.sort()
		index = bisect.bisect_right(a, x)
		if index == 0:
			print(0)
			return
		print((index + 1) // 2)
main()


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))

def solve():
	if x > y:
		return len(a)
	else:
		t = len([ai for ai in a if ai <= x])
		return t // 2 + t % 2
print(solve())


(n, x, y) = list(map(int, input().split()))
m = list(map(int, input().split()))
if x > y:
	print(n)
else:
	s = 0
	for i in range(n):
		if m[i] <= x:
			s += 1
	print((s + 1) // 2)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
if x > y:
	print(n)
else:
	for i in range(n * 100):
		if not i % 2:
			l[l.index(min(l))] -= x
			l = [i for i in l if i > 0]
			if not len(l):
				break
		else:
			l[l.index(min(l))] += y
	print(n - len(l))


(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	a.sort()
	i = 0
	while i < n and a[i] <= x:
		i += 1
	print(i // 2 + i % 2)


(N, X, Y) = map(int, input().split())
A = sorted(list(map(int, input().split())))
while len(A) > 0 and A[-1] > X:
	A.pop()
A = A[::-1]
if X > Y:
	print(N)
else:
	ans = 0
	state = 0
	for i in A:
		if state == 0:
			if i <= X:
				ans += 1
		elif i + Y > X:
			pass
		else:
			ans += 1
		state = 1 - state
	print(ans)


(n, x, y) = [int(i) for i in input().split()]
doors = [int(i) for i in input().split()]
if x > y:
	print(n)
elif y >= x:
	r = 1 + sum([1 for door in doors if door <= x])
	print(r // 2)


(n, x, y) = map(int, input().split())
doors = list(map(int, input().split()))
doors.sort()
k = 0
if x > y:
	k = n
elif x <= y:
	for door in doors:
		if door <= x:
			k += 1
	k = (k + 1) // 2
print(k)


def solve(rem_tests):
	if not rem_tests:
		return
	res = 0
	(n, x, y) = map(int, input().split())
	a = list(map(int, input().split()))
	for i in a:
		if i <= x:
			res += 1
	if x > y:
		print(n)
	else:
		print(int(res >> 1) + (res & 1))
	solve(rem_tests - 1)
solve(1)


import math
(n, x, y) = [int(i) for i in input().split()]
ans = 0
cnt = 0
if x <= y:
	for i in input().split():
		t = int(i)
		if t <= x:
			cnt += 1
	ans = math.ceil(cnt / 2)
elif x > y:
	ans = n
print(ans)


import sys
r = lambda : sys.stdin.readline().strip()
(n, x, y) = map(int, r().split())
a = list(map(int, r().split()))
if x > y:
	print(n)
else:
	k = 0
	for i in a:
		if i <= x:
			k += 1
	print(k // 2 + k % 2)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	tmp = 0
	for v in a:
		if v <= x:
			tmp += 1
	if tmp % 2 == 0:
		print(tmp // 2)
	else:
		print(tmp // 2 + 1)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
	exit(0)
ans = 0
for i in a:
	ans += i <= x
print((ans + 1) // 2)


from math import ceil
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	cnt = 0
	for item in a:
		if item <= x:
			cnt += 1
	print(ceil(cnt / 2))


def main():
	inp = input().split()
	n = int(inp[0])
	x = int(inp[1])
	y = int(inp[2])
	a = [int(s) for s in input().split()]
	if x <= y:
		k = 0
		for i in range(len(a)):
			if a[i] <= x:
				k += 1
		kd = k / 2 + k % 2
		print(int(kd))
	else:
		print(n)
main()


import math
(n, x, y) = list(map(int, input().split()))
doors = list(map(int, input().split()))
done = 0
moves = 0
less_x = 0
for d in doors:
	if d <= x:
		less_x += 1
done += math.ceil(less_x / 2)
moves = done
if y >= x:
	print(done)
	exit()
print(n)


import math
temp = map(int, input().split(' '))
(n, x, y) = temp
q = sorted(list(map(int, input().split(' '))))
t = 0
if x > y:
	print(n)
else:
	for i in range(0, n):
		if q[i] <= x:
			t = t + 1
	print(math.ceil(t / 2))


from bisect import *
from heapq import *
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
heapify(a)
c = 0
if x > y:
	print(n)
else:
	while 1:
		if len(a) == 0:
			break
		x1 = heappop(a)
		if x1 > x:
			break
		c += 1
		if len(a) != 0:
			x1 = heappop(a)
			heappush(a, x1 + y)
	print(c)


from math import ceil
(n, x, y) = map(int, input().strip().split())
arr = list(map(int, input().strip().split()))
if x > y:
	print(n)
else:
	less_than_x = sum([ele <= x for ele in arr])
	print(ceil(less_than_x / 2))


import sys
from math import ceil
read = sys.stdin.buffer.readline
mi = lambda : map(int, read().split())
li = lambda : list(mi())
cin = lambda : int(read())
d = {'RR': 'G', 'RG': 'B', 'GR': 'B', 'RB': 'G', 'BR': 'G', 'GG': 'R', 'GB': 'R', 'BG': 'R', 'BB': 'R'}
for _ in range(1):
	(n, x, y) = mi()
	a = li()
	if x > y:
		print(n)
	else:
		noe = 0
		for el in a:
			if el <= x:
				noe += 1
		print(ceil(noe / 2))


(n, x, y) = map(int, input().split())
l = [int(i) for i in input().split()]
l.sort()
from math import ceil
if x > y:
	print(n)
	exit()
from bisect import bisect_left as bl
c = sum((i <= x for i in l))
print(ceil(c / 2))


(n, x, y) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
if x > y:
	print(n)
else:
	a.sort()
	z = 0
	c = 0
	for xx in range(n):
		if a[xx] + z <= x:
			c = c + 1
			z = z + y
		else:
			z = 0
	print(c)


import math
(n, x, y) = [int(x) for x in input().split()]
dur = [int(x) for x in input().split()]
if x > y:
	print(n)
else:
	count = 0
	for i in range(n):
		if x >= dur[i]:
			count = count + 1
	print(math.ceil(count / 2))


(n, x, y) = input().split()
(n, x, y) = (int(n), int(x), int(y))
a = input().split()
a = [int(i) for i in a]
if x > y:
	f = n
else:
	a.append(x + 1)
	a.sort()
	i = a.index(x + 1)
	if i % 2 == 0:
		f = i / 2
	else:
		f = (i + 1) / 2
print(int(f))


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
c1 = 0
for i in range(n):
	if l[i] <= x:
		c1 += 1
if x > y:
	print(n)
else:
	print(int(c1 / 2 + 0.5))


from collections import Counter
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
import math

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

def divs(n, start=2):
	divisors = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				divisors.append(i)
			else:
				divisors.extend([i, n // i])
	return divisors
import sys
import bisect
(n, x, y) = map(int, input().split())
arr = list(map(int, sys.stdin.readline().split()))
arr.sort()
if x > y:
	print(n)
elif x == y:
	var = bisect.bisect_right(arr, x)
	print(var // 2 if var % 2 == 0 else var // 2 + 1)
else:
	var = bisect.bisect_right(arr, x)
	print(var // 2 if var % 2 == 0 else var // 2 + 1)


from math import ceil
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
if x <= y:
	print(ceil(len(list(filter(lambda _: _ <= x, a))) / 2))


(n, x, y) = list(map(int, input().split()))
doors = list(map(int, input().split()))
if x > y:
	print(n)
	exit()
aim_doors = [door for door in doors if door <= x]
chet = len(aim_doors) % 2 == 0
if chet:
	print(len(aim_doors) // 2)
else:
	print(len(aim_doors) // 2 + 1)


import math
(n, x, y) = map(int, input().split())
a = [int(x) for x in input().split()]
if x > y:
	print(n)
else:
	counter = 0
	for i in a:
		if x >= i:
			counter += 1
	print(math.ceil(counter / 2))


import math
(n, x, y) = map(int, input().split())
ar = list(map(int, input().split()))
l = len([ar[i] for i in range(0, n) if ar[i] <= x])
if x > y:
	print(n)
else:
	print(math.ceil(l / 2))


first = [int(x) for x in input().split()]
doors = [int(x) for x in input().split()]
doors.sort()
original_length = first[0]
hero_power = first[1]
villian_power = first[2]
if villian_power == 0 or hero_power > villian_power:
	print(original_length)
elif hero_power <= villian_power:
	y = 0
	for x in range(original_length):
		if doors[x] <= hero_power:
			y += 1
		else:
			break
	ans = y // 2
	if ans != y / 2:
		ans += 1
	print(ans)
else:
	print('Error')


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	s = 0
	for i in a:
		s += i
	d = s / (x - y)
	if d > 10 ** 100:
		a.sort()
		s = 0
		g = 1
		for i in range(a):
			s += (a[i] - 1) % (x - y)
			if s > 10 ** 100:
				print(i)
				g = 0
				break
		if g:
			print(n)
	else:
		print(n)
else:
	f = 0
	for i in a:
		if i <= x:
			f += 1
	print((f - 1) // 2 + 1)


import math
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	ans = 0
	ans2 = 0
	for i in a:
		if i <= x and i + y > x:
			ans += 1
		elif i <= x:
			ans2 += 1
	print(math.ceil(ans / 2) + ans2)


(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
if x - y > 0:
	print(n)
else:
	arr.sort()
	count = 0
	for i in arr:
		if i <= x:
			count += 1
		else:
			break
	if count % 2 == 0:
		print(count // 2)
	else:
		print(count // 2 + 1)


(x, n, m) = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
if n > m:
	print(x)
else:
	a = 0
	for i in arr:
		if i <= n:
			a += 1
	if a % 2 == 0:
		print(a // 2)
	else:
		print(a // 2 + 1)


(n, x, y) = map(int, input().strip().split())
ais = map(int, input().strip().split())
if x > y:
	print(n)
else:
	count = 0
	for ai in ais:
		if ai <= x:
			count += 1
	print((count + 1) // 2)


import math
from sys import stdin, stdout
input = stdin.readline
listin = lambda : list(map(int, input().split()))
mapin = lambda : map(int, input().split())
(n, x, y) = mapin()
a = listin()
count = 0
for i in a:
	if i <= x:
		count += 1
if x > y:
	print(n)
else:
	print(math.ceil(count / 2))


def count_doors_strong_less_then_or_equal_to(s: int):
	global n, x, y, a
	cnt = 0
	for ds in a:
		if ds <= s:
			cnt += 1
	return cnt
(n, x, y) = [int(z) for z in input().split()]
a = [int(z) for z in input().split()]
td = count_doors_strong_less_then_or_equal_to(x)
if x <= y:
	print(0 if td == 0 else 1 + (td - 1) // 2)
elif x > y:
	print(n)


from math import ceil
(n, x, y) = map(int, input().split())
li = list(map(int, input().split()))
if x > y:
	print(len(li))
else:
	num = 0
	for i in li:
		if i <= x:
			num += 1
	print(ceil(num / 2))


gi = lambda : list(map(int, input().strip().split()))
(n, x, y) = gi()
l = gi()
if x > y:
	print(n)
	exit()
p = [e for e in l if e <= x]
print(len(p) // 2 + len(p) % 2)


import math
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
cnt = 0
if x > y:
	print(len(a))
else:
	for i in a:
		if i <= x:
			cnt += 1
	print(math.ceil(cnt / 2))


(n, x, y) = map(int, input().split())
D = sorted([*map(int, input().split())])
ans = 0
if x > y:
	ans = n
else:
	for i in range(n):
		if D[i] > x:
			break
		if i % 2 == 0:
			ans += 1
print(ans)


class Solution(object):

	def getNumbeOfDoorsWithZeroDurability(self, arr, x, y):
		if x > y:
			return len(arr)
		countDoorsLessThanX = 0
		for num in arr:
			if num <= x:
				countDoorsLessThanX += 1
		return int((countDoorsLessThanX + 1) / 2)

def read_input():
	return [int(x) for x in input().split()]
line = read_input()
n = line[0]
x = line[1]
y = line[2]
arr = read_input()
sol = Solution()
result = sol.getNumbeOfDoorsWithZeroDurability(arr, x, y)
print(result)


from math import ceil
(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
if x > y:
	print(n)
else:
	coun = 0
	for c in l:
		if c <= x:
			coun += 1
	print(ceil(coun / 2))


R = lambda : map(int, input().split())
(n, x, y) = R()
L = sorted(R())
if x > y:
	print(n)
else:
	res = 0
	for i in range(0, n, 2):
		if L[i] <= x:
			res += 1
		else:
			break
	print(res)


I = lambda : map(int, input().split())
(n, x, y) = I()
print(n if x > y else (1 + sum((a <= x for a in I()))) // 2)


from bisect import bisect_left
from collections import deque

def solve():
	(n, x, y) = map(int, input().split())
	B = [int(k) for k in input().split()]
	if x > y:
		print(n)
		return
	B.sort()
	B = deque(B)
	cnt = 0
	while B:
		i = bisect_left(B, x)
		if i == len(B):
			i -= 1
		if B[i] > x:
			if i > 0:
				i -= 1
			else:
				break
		cnt += 1
		del B[i]
		if B:
			B[0] += y
			if B[0] > x:
				B.popleft()
			else:
				B.sort()
	print(cnt)
solve()


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
c = len([i for i in l if i <= x])
if x > y:
	print(n)
else:
	print((c + 1) // 2)


import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda : int(input())
li = lambda : list(map(int, input().split()))

def case():
	(n, x, y) = li()
	a = li()
	c = 0
	for i in range(n):
		if a[i] <= x:
			c += 1
	if x > y:
		print(n)
	else:
		print(int(math.ceil(c / 2)))
for _ in range(1):
	case()


(n, x, y) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
if x <= y:
	a.sort()
	amount = 0
	i = 0
	while i < n and a[i] - x <= 0:
		amount += 1
		if i != n - 1:
			a[i + 1] += y
			a.sort()
		i += 1
	print(amount)
elif x > y:
	print(n)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(len(a))
else:
	print((len(list(filter(lambda p: p <= x, a))) + 1) // 2)


sa = lambda : input()
sb = lambda : int(input())
sc = lambda : input().split()
sd = lambda : list(map(int, input().split()))
se = lambda : float(input())

def hnbhai():
	(n, x, y) = sd()
	a = sd()
	if x > y:
		print(n)
		return
	t = 0
	for i in a:
		if i <= x:
			t += 1
	print(-(-t // 2))
hnbhai()


(n, x, y) = map(int, input().split())
if x <= y:
	d = input()
	do = list(map(int, d.split()))
	ans = 0
	for i in do:
		if i <= x:
			ans += 1
	ans = (ans + 1) // 2
	print(ans)
else:
	print(n)


import os
import sys
import math
import collections
import cmath

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

def inp():
	return input()
(n, x, y) = mp()
ar = list(mp())
ar.sort()
cnt = 0
if x > y:
	print(n)
else:
	for i in range(n):
		if i % 2 == 0:
			if ar[i] <= x:
				cnt += 1
			else:
				break
		elif ar[i] + y <= x:
			cnt += 1
		else:
			continue
	print(cnt)


inp1 = input().split(' ')
my = int(inp1[1])
s = int(inp1[2])
ans = 0
if my > s:
	print(inp1[0])
	exit()
else:
	maybe = []
	inp2 = input().split(' ')
	for num in inp2:
		num = int(num)
		if num <= my:
			maybe.append(num)
	print((len(maybe) + 1) // 2)


import math
(n, x, y) = map(int, input().split())
arr = [int(x) for x in input().split()]
if x > y:
	print(n)
else:
	count = 0
	for i in arr:
		if i <= x:
			count += 1
	print(math.ceil(count / 2))


from collections import *
(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
if x > y:
	print(len(arr))
elif x <= y:
	avai = []
	for a in arr:
		if a <= x:
			avai.append(a)
	avai.sort()
	avai = deque(avai)
	killed = 0
	desTurn = 1
	while avai:
		if desTurn:
			avai.pop()
			killed += 1
			desTurn = 0
		else:
			avai.popleft()
			desTurn = 1
	print(killed)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x <= y:
	c = 0
	for i in range(n):
		if a[i] <= x:
			c += 1
	ans = c // 2 + c % 2
	print(ans)
elif x > y:
	print(n)


(n, x, y) = map(int, input().split())
a = map(int, input().split())
if x > y:
	print(n)
elif x <= y:
	k = 0
	for i in a:
		if i <= x:
			k += 1
	print((k - 1) // 2 + 1)


from sys import stdin
(n, x, y) = list(map(int, stdin.readline().split()))
door = list(map(int, stdin.readline().split()))
if x > y:
	print(n)
	exit()
count = 0
for i in range(n):
	if door[i] - x <= 0:
		count += 1
if count % 2 == 0:
	print(count // 2)
else:
	print(count // 2 + 1)


l1 = list(map(int, input().split()))
l2 = list(map(int, input().split()))
if l1[1] > l1[2]:
	print(l1[0])
else:
	sum = 0
	for i in l2:
		if i <= l1[1]:
			sum += 1
	if sum % 2 == 0:
		print(sum // 2)
	else:
		print(sum // 2 + 1)


(n, x, y) = map(int, input().split())
an = [int(an) for an in input().split()]
count = 0
if x > y:
	print(n)
elif x <= y:
	for i in range(0, n):
		if an[i] <= x:
			count += 1
	print((count + 1) // 2)


(n, x, y) = map(int, input().split())
arr = [int(x) for x in input().split()]
if x > y:
	print(n)
else:
	i = 0
	arr.sort(reverse=True)
	while arr:
		arr[-1] -= x
		if arr[-1] <= 0:
			i += 1
			arr.pop()
			if not arr:
				print(n)
				break
			arr[-1] += y
			arr.sort(reverse=True)
		else:
			print(i)
			break
	else:
		print(i)


nxy = [int(i) for i in input().split()]
n = nxy[0]
x = nxy[1]
y = nxy[2]
arr = [int(i) for i in input().split()]
if y >= x:
	uWeak = 0
	for i in range(n):
		if arr[i] <= x:
			uWeak = uWeak + 1
	if uWeak % 2 == 0:
		print(int(uWeak / 2))
	else:
		print(int((uWeak + 1) / 2))
else:
	print(n)


cnt = 0
b = []
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
elif y >= x:
	for i in range(n):
		if a[i] <= x:
			b.append(a[i])
	if len(b) % 2 == 0:
		print(len(b) // 2)
	if len(b) % 2 != 0:
		print(len(b) // 2 + 1)


mod = 10 ** 9 + 7
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
(n, x, y) = f()
c = 0
l = il()
if x > y:
	exit(print(n))
for i in l:
	if i <= x:
		c += 1
print((c + 1) // 2)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
cur = 0
if x > y:
	print(len(l))
elif x <= y:
	for i in range(n):
		if l[i] <= x:
			cur += 1
	print((cur + 1) // 2)


(n, x, y) = input().split(' ')
(n, x, y) = (int(n), int(x), int(y))
a = input().split(' ')
a = [int(i) for i in a]
if x > y:
	print(n)
	quit()
a.sort()
cnt = 0
for i in range(n):
	if a[i] <= x:
		cnt += 1
	else:
		break
print((cnt + 1) // 2)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
l1 = [i > x for i in l]
if x > y:
	print(n)
else:
	k = l1.count(False)
	if k % 2 == 0:
		print(k // 2)
	else:
		print((k + 1) // 2)


(n, x, y) = map(int, input().strip().split())
c = [int(_) for _ in input().strip().split()]
if x > y:
	print(n)
else:
	from math import ceil
	print(ceil(len([i for i in c if i <= x]) / 2))


(n, x, y) = map(int, input().split())
ar = list(map(int, input().split()))
if x > y:
	print(n)
elif x <= y:
	ch = len([m for m in ar if m <= x])
	if ch % 2 == 0:
		print(ch // 2)
	else:
		print(ch // 2 + 1)


(n, x, y) = map(int, input().split())
ar = list(map(int, input().split()))
if x > y:
	print(n)
else:
	ar1 = sorted(ar)
	a = 0
	for i in ar1:
		if i <= x:
			i = i + 1
			a = a + 1
		else:
			break
	print((a + 1) // 2)


(n, x, y) = map(int, input().split())
arr = sorted(list(map(int, input().split())))
lessnums = 0
for i in arr:
	if i <= x:
		lessnums += 1
	else:
		break
if x > y:
	print(n)
else:
	print(int((lessnums + 1) / 2))


(n, x, y) = [int(x) for x in input().strip().split()]
a = [int(x) for x in input().strip().split()]
a = sorted(a)
count = 0
for i in range(n):
	elem = a[i]
	if elem <= x:
		count += 1
	else:
		ind = i
		break
if x <= y:
	res = (count - 1) // 2 + 1
else:
	res = 0
	step = 10 ** 100 - count
	for i in range(n):
		step = step - (a[i] - 1) // (x - y) + 1
		if step < 0:
			break
		elif step == 0:
			res += 1
		else:
			res += 1
print(res)


(n, x, y) = [int(s) for s in input().split()]
if y >= x:
	ans = 0
	for i in input().split():
		i = int(i)
		if i <= x:
			ans += 1
	print(ans // 2 + ans % 2)
else:
	print(n)


(n, x, y) = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
if x > y:
	ans = n
else:
	B = []
	for a in A:
		if a <= x:
			B.append(a)
	m = len(B)
	ans = m - m // 2
print(ans)


(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
if x <= y:
	c = 0
	arr = sorted(arr)
	for i in range(0, len(arr), 2):
		if arr[i] <= x:
			c += 1
	print(c)
	return
if x > y:
	c = 0
	print(n)


import math
(n, x, y) = map(int, input().split())
doors = map(int, input().split())
if x > y:
	print(n)
else:
	count = 0
	for d in doors:
		if d <= x:
			count += 1
	count /= 2
	res = int(math.ceil(count))
	print(res)


(n, x, y) = list(map(int, input().split()))
doors = list(map(int, input().split()))
possible = 0
repair = 0
for i in range(len(doors)):
	if doors[i] <= x:
		possible += 1
if x > y:
	print(n)
else:
	print(int((possible + 1) / 2))


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
if y >= x:
	b = []
	for c in a:
		if c <= x:
			b.append(c)
	count = 0
	m = len(b)
	i = 0
	while i < m:
		if b[i] <= x:
			count += 1
			b[-1] += y
			if b[-1] > x:
				m -= 1
				b.pop(-1)
		i += 1
	print(count)
else:
	print(len(a))


(n, x, y) = map(int, input().split())
a = [int(e) for e in input().split()]
if x > y:
	print(n)
	exit(0)
cnt = 0
for i in a:
	if i <= x:
		cnt += 1
print((cnt + 1) // 2)


from sys import stdin, stdout
import cProfile, math
from collections import Counter
from bisect import bisect_left, bisect, bisect_right
import itertools
from copy import deepcopy
from fractions import Fraction
import sys, threading
import operator as op
from functools import reduce
sys.setrecursionlimit(10 ** 6)
threading.stack_size(2 ** 27)
printHeap = str()
memory_constrained = False
P = 10 ** 9 + 7
import sys
sys.setrecursionlimit(10000000)

class Operation:

	def __init__(self, name, function, function_on_equal, neutral_value=0):
		self.name = name
		self.f = function
		self.f_on_equal = function_on_equal

def add_multiple(x, count):
	return x * count

def min_multiple(x, count):
	return x

def max_multiple(x, count):
	return x
sum_operation = Operation('sum', sum, add_multiple, 0)
min_operation = Operation('min', min, min_multiple, 1000000000.0)
max_operation = Operation('max', max, max_multiple, -1000000000.0)

class SegmentTree:

	def __init__(self, array, operations=[sum_operation, min_operation, max_operation]):
		self.array = array
		if type(operations) != list:
			raise TypeError('operations must be a list')
		self.operations = {}
		for op in operations:
			self.operations[op.name] = op
		self.root = SegmentTreeNode(0, len(array) - 1, self)

	def query(self, start, end, operation_name):
		if self.operations.get(operation_name) == None:
			raise Exception('This operation is not available')
		return self.root._query(start, end, self.operations[operation_name])

	def summary(self):
		return self.root.values

	def update(self, position, value):
		self.root._update(position, value)

	def update_range(self, start, end, value):
		self.root._update_range(start, end, value)

	def __repr__(self):
		return self.root.__repr__()

class SegmentTreeNode:

	def __init__(self, start, end, segment_tree):
		self.range = (start, end)
		self.parent_tree = segment_tree
		self.range_value = None
		self.values = {}
		self.left = None
		self.right = None
		if start == end:
			self._sync()
			return
		self.left = SegmentTreeNode(start, start + (end - start) // 2, segment_tree)
		self.right = SegmentTreeNode(start + (end - start) // 2 + 1, end, segment_tree)
		self._sync()

	def _query(self, start, end, operation):
		if end < self.range[0] or start > self.range[1]:
			return None
		if start <= self.range[0] and self.range[1] <= end:
			return self.values[operation.name]
		self._push()
		left_res = self.left._query(start, end, operation) if self.left else None
		right_res = self.right._query(start, end, operation) if self.right else None
		if left_res is None:
			return right_res
		if right_res is None:
			return left_res
		return operation.f([left_res, right_res])

	def _update(self, position, value):
		if position < self.range[0] or position > self.range[1]:
			return
		if position == self.range[0] and self.range[1] == position:
			self.parent_tree.array[position] = value
			self._sync()
			return
		self._push()
		self.left._update(position, value)
		self.right._update(position, value)
		self._sync()

	def _update_range(self, start, end, value):
		if end < self.range[0] or start > self.range[1]:
			return
		if start <= self.range[0] and self.range[1] <= end:
			self.range_value = value
			self._sync()
			return
		self._push()
		self.left._update_range(start, end, value)
		self.right._update_range(start, end, value)
		self._sync()

	def _sync(self):
		if self.range[0] == self.range[1]:
			for op in self.parent_tree.operations.values():
				current_value = self.parent_tree.array[self.range[0]]
				if self.range_value is not None:
					current_value = self.range_value
				self.values[op.name] = op.f([current_value])
		else:
			for op in self.parent_tree.operations.values():
				result = op.f([self.left.values[op.name], self.right.values[op.name]])
				if self.range_value is not None:
					bound_length = self.range[1] - self.range[0] + 1
					result = op.f_on_equal(self.range_value, bound_length)
				self.values[op.name] = result

	def _push(self):
		if self.range_value is None:
			return
		if self.left:
			self.left.range_value = self.range_value
			self.right.range_value = self.range_value
			self.left._sync()
			self.right._sync()
			self.range_value = None

	def __repr__(self):
		ans = '({}, {}): {}\n'.format(self.range[0], self.range[1], self.values)
		if self.left:
			ans += self.left.__repr__()
		if self.right:
			ans += self.right.__repr__()
		return ans

def display(string_to_print):
	stdout.write(str(string_to_print) + '\n')

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer / denom

def primeFactors(n):
	factors = dict()
	for i in range(2, math.ceil(math.sqrt(n)) + 1):
		while n % i == 0:
			if i in factors:
				factors[i] += 1
			else:
				factors[i] = 1
			n = n // i
	if n > 2:
		factors[n] = 1
	return factors

def isprime(n):
	if n < 4:
		return True
	if n % 2 == 0:
		return False
	if n % 3 == 0:
		return False
	i = 5
	w = 2
	while i * i <= n:
		if n % i == 0:
			return False
		i += w
		w = 6 - w
	return True

def test_print(*args):
	if testingMode:
		print(args)

def display_list(list1, sep=' '):
	stdout.write(sep.join(map(str, list1)) + '\n')

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

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

def get_list():
	return list(map(int, stdin.readline().split()))
memory = dict()

def clear_cache():
	global memory
	memory = dict()

def cached_fn(fn, *args):
	global memory
	if args in memory:
		return memory[args]
	else:
		result = fn(*args)
		memory[args] = result
		return result
TestCases = False
testingMode = False
optimiseForReccursion = False

def main():
	(n, x, y) = get_tuple()
	li = get_list()
	if x > y:
		print(n)
		return
	c = 0
	for i in li:
		if i <= x:
			c += 1
	print(math.ceil(c / 2))
if TestCases:
	for _ in range(get_int()):
		cProfile.run('main()') if testingMode else main()
else:
	(cProfile.run('main()') if testingMode else main()) if not optimiseForReccursion else threading.Thread(target=main).start()


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
t = 0
for i in a:
	if i <= x:
		t = t + 1
	else:
		break
if x > y:
	print(n)
elif x <= y:
	if t % 2 == 0:
		print(int(t / 2))
	else:
		print(int(t // 2 + 1))


(n, x, y) = list(map(int, input().strip().split()))
a = list(map(int, input().strip().split()))
if x > y:
	print(n)
else:
	s = sum([ai <= x for ai in a])
	print(int(s / 2) + s % 2)


from math import ceil
(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
if x > y:
	print(n)
if x <= y:
	print(ceil(len(list([_ for _ in a if _ <= x])) / 2))


(n, x, y) = map(int, input().split())
en = list(map(int, input().split()))
if x > y:
	print(n)
	exit()
nn = list(filter(lambda enn: x >= enn, en))
print((len(nn) + 1) // 2)


R = lambda : map(int, input().split())
(n, x, y) = R()
a = R()
b = [k for k in a if k <= x]
if x > y:
	print(n)
else:
	print((len(b) + 1) // 2)


(n, x, y) = tuple(map(int, input().split()))
arr = list(map(int, input().split()))
less = 0
if x <= y:
	for a in arr:
		if a <= x:
			less += 1
	print((less + 1) // 2)
else:
	print(n)


(n, x, y) = map(int, input().split())
a = sorted(list(map(int, input().split())))
if x > y:
	print(n)
else:
	k = 0
	for i in range(n):
		if a[i] <= x:
			k += 1
	print(-(-k // 2))


rd = lambda : list(map(int, input().split()))
((n, x, y), a) = (rd(), rd())
print(n if x > y else (len([z for z in a if z <= x]) + 1) // 2)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
ans = 0
if x <= y:
	able = 0
	for t in l:
		if t <= x:
			able += 1
	ans = able // 2 + able % 2
else:
	ans = n
print(ans)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	b = list(filter(lambda m: m <= x, a))
	c = len(b)
	print((c >> 1) + (c & 1))


import math
from collections import defaultdict
ml = lambda : map(int, input().split())
ll = lambda : list(map(int, input().split()))
ii = lambda : int(input())
ip = lambda : input()
(x, y, z) = ml()
a = ll()
if y > z:
	print(x)
else:
	ans = 0
	for i in a:
		if i <= y:
			ans += 1
	print(math.ceil(ans / 2))


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
	exit()
b = list(filter(lambda s: x >= s, a))
print((len(b) + 1) // 2)


(n, z, y) = map(int, input().split())
(c, r, i, d) = ([], [], 0, 0)
for _ in map(int, input().split()):
	i += 1
	c.append([_, i])
c.sort(key=lambda x: x[0])
if y >= z:
	print((len(list(filter(lambda v: v[0] <= z, c))) + 1) // 2)
else:
	print(n)


(z, zz, dgraphs) = (input, lambda : list(map(int, z().split())), {})
from string import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
(n, x, y) = zz()
l = zz()
if x > y:
	print(n)
	exit()
c = 0
for i in l:
	if x <= y:
		if i - x <= 0:
			c += 1
	if x > y:
		c += 1
print((c + 1) // 2)


(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
if x > y:
	print(n)
elif x <= y:
	a = sorted(a)
	if a[0] > x:
		print(0)
	else:
		(ans, i) = (0, 0)
		while i < n and a[i] <= x:
			ans += 1
			i += 1
		print((ans + 1) // 2)


(n, x, y) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
if y >= x:
	print((len([i for i in a if i <= x]) + 1) // 2)
else:
	print(n)


(a, b, c) = map(int, input().split())
l = sorted(list(map(int, input().split())))
if b > c:
	sums = sum(l)
	if 10 ** 100 * (b - c) > sums:
		print(a)
	else:
		for i in l[::-1]:
			if sums - i > 10 ** 100 * (b - c):
				sums -= i
				a -= 1
			else:
				print(a)
				break
else:
	cnt = 0
	for i in l:
		if i <= b:
			cnt += 1
	if cnt % 2 == 0:
		print(cnt // 2)
	else:
		print(cnt // 2 + 1)


(n, x, y) = list(map(int, input().split()))
l = list(map(int, input().split()))
if x <= y:
	cnt = 0
	ans = 0
	for i in range(n):
		if l[i] <= x:
			cnt += 1
	if cnt % 2 == 1:
		ans += 1
	ans += cnt // 2
	print(ans)
else:
	print(n)


def solve(n, x, y, values):
	if x > y:
		return n
	values = list(filter(lambda v: v <= x, values))
	return (len(values) + 1) // 2
(n, x, y) = map(int, input().strip().split(' '))
values = list(map(int, input().strip().split(' ')))
print(solve(n, x, y, values))


[n, x, y] = [int(s) for s in input().split()]
a = [int(s) for s in input().split()]
if x <= y:
	k = 0
	for i in range(a.__len__()):
		if a[i] <= x:
			k += 1
	print(k // 2 + k % 2)
	exit(0)
else:
	print(n)


(n, x, y) = map(int, input().split())
a = sorted(list(map(int, input().split())))
(behon, behonbang) = (0, 0)
for u in a:
	behon += u < x
	behonbang += u <= x
if x <= y:
	print((behonbang + 1) // 2)
if x > y:
	print(n)


(a, b, c) = list(map(int, input().split()))
d = list(map(int, input().split()))
if b > c:
	print(a)
else:
	smaller = 0
	for i in range(len(d)):
		if d[i] <= b:
			smaller += 1
	print(int(smaller / 2 + 0.5))


(n, x, y) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
if x > y:
	print(n)
else:
	ct = 0
	for i in a:
		if i <= x:
			ct += 1
	print(ct // 2 + ct % 2)


arr = input()
(N, X, Y) = [int(x) for x in arr.split(' ')]
arr = input()
arr = [int(x) for x in arr.split(' ')]
res = 0
less = 0
if X > Y:
	print(N)
	quit()
for i in range(N):
	if arr[i] <= X:
		less += 1
if less % 2 == 0:
	print(less // 2)
else:
	print(less // 2 + 1)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
l = n
count = 0
if x > y:
	print(len(a))
elif x <= y:
	for i in range(len(a)):
		if a[i] <= x:
			count += 1
		else:
			break
	if count % 2 == 0:
		print(int(count / 2))
	else:
		count = int(count / 2) + 1
		print(count)


(n, x, y) = input().split()
(n, x, y) = (int(n), int(x), int(y))
lt = [int(p) for p in input().split()]
if x > y:
	print(len(lt))
else:
	cnt = 0
	for i in lt:
		if i <= x:
			cnt += 1
	cnt += 1
	cnt = cnt // 2
	print(cnt)


from math import ceil
(n, x, y) = [int(i) for i in input().split()]
l = [int(i) for i in input().split()]
if x > y:
	print(n)
else:
	sum = 0
	for i in range(n):
		if l[i] <= x:
			sum = sum + 1
	print(ceil(sum / 2))


from sys import stdin, stdout
from math import *
from heapq import *
from collections import *

def main():
	(n, x, y) = [int(x) for x in stdin.readline().split()]
	a = [int(x) for x in stdin.readline().split()]
	c = [0] * 100002
	for t in a:
		c[t] = c[t] + 1
	res = 0
	if x > y:
		res = n
	elif x <= y:
		res = trunc((sum(c[:x + 1]) + 1) / 2)
	stdout.write(str(res))
	return 0
main()


strings = input()
n = int(strings.split(' ')[0])
x = int(strings.split(' ')[1])
y = int(strings.split(' ')[2])
strings = input()
lst = strings.split(' ')
if x > y:
	print(n)
else:
	count1 = count2 = count3 = 0
	for each in lst:
		if int(each) > x:
			count3 = count3 + 1
		elif int(each) == x:
			count2 = count2 + 1
		else:
			count1 = count1 + 1
	if (count1 + count2) % 2 == 1:
		print(int((count1 + count2) / 2 + 1))
	else:
		print(int((count1 + count2) / 2))


def police(l, x, y):
	if x > y:
		print(len(l))
		return 0
	if min([i for i in l if i > 0]) > x and y >= x:
		k = l.index(min([i for i in l if i > 0]))
		z = l[k] - x
		if z < 0:
			l[k] = 0
		else:
			l[k] = z
		print(l.count(0))
		return 0
	else:
		k = l.index(min([i for i in l if i > 0]))
		z = l[k] - x
		if z < 0:
			l[k] = 0
		else:
			l[k] = z
		if max(l) == 0:
			print(l.count(0))
			return 0
		thief(l, x, y)

def thief(l, x, y):
	k = l.index(min([i for i in l if i > 0]))
	l[k] = l[k] + y
	police(l, x, y)
i = input()
i = list(map(int, i.split()))
x = i[1]
y = i[2]
l = input()
l = list(map(int, l.split()))
police(l, x, y)


(n, a, d) = map(int, input().split())
dat = list(map(int, input().split()))
if a > d:
	print(n)
else:
	t = 0
	for i in range(n):
		if dat[i] <= a:
			t += 1
	import math
	print(math.ceil(t / 2))


import math

def main():
	(n, x, y) = map(int, input().split())
	dur = list(map(int, input().split()))
	if x > y:
		print(n)
	else:
		count = 0
		for i in dur:
			if i <= x:
				count += 1
		print(int(math.ceil(count / 2)))
main()


import math
(n, x, y) = [int(i) for i in input().split()]
doors = list([int(i) for i in input().split()])
if x > y:
	print(n)
elif y >= x:
	n = 0
	for door in doors:
		if door <= x:
			n += 1
	print(math.ceil(n / 2))


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
	exit(0)
a.sort()
p = -1
for i in range(n):
	if a[i] <= x:
		p = i
	else:
		break
rem = (p + 1) // 2 + (p + 1) % 2
print(rem)


from os import path
from io import BytesIO, IOBase
import sys
from heapq import heappush, heappop
from functools import cmp_to_key as ctk
from collections import deque, Counter, defaultdict as dd
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from itertools import permutations
from datetime import datetime
from math import ceil, sqrt, log, gcd

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

def si():
	return input().rstrip()

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

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
mod = 998244353
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def bo(i):
	return ord(i) - ord('0')
file = 1

def ceil(a, b):
	return (a + b - 1) // b

def solve():
	(n, x, y) = mi()
	a = li()
	if x > y:
		print(n)
		return
	c = 0
	for i in a:
		if i <= x:
			c += 1
	print(ceil(c, 2))
if file:
	if path.exists('input.txt'):
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	else:
		input = sys.stdin.readline
solve()


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	z = [i for i in a if i <= x]
	(b, k) = divmod(len(z), 2)
	print(b + k)


def ia():
	n = input().split()
	return list(map(int, n))

def ic():
	return input().split()

def ii():
	return int(input())
import math
(n, x, y) = ia()
a = ia()
if x > y:
	print(n)
else:
	count = 0
	for i in a:
		if i <= x:
			count += 1
	print(int(math.ceil(count / 2)))


import math
(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
if x > y:
	print(n)
else:
	c = 0
	for i in range(n):
		if l[i] <= x:
			c += 1
	print(math.ceil(c / 2))


(n, x, y) = map(int, input().split())
doors = list(map(int, input().split()))
door_can_broke = 0
if x > y:
	print(len(doors))
else:
	for door in doors:
		if door <= x:
			door_can_broke += 1
	if door_can_broke / 2 == door_can_broke // 2:
		print(door_can_broke // 2)
	else:
		print(door_can_broke // 2 + 1)


(n, x, y) = map(int, input().split())
a = sorted(list(map(int, input().split())))
ans = 0
if x > y:
	print(len(a))
	exit()
for i in range(len(a)):
	a.sort()
	a[i] -= x
	if a[i] < 1:
		ans += 1
		a[min(i + 1, len(a) - 1)] += y
	else:
		print(ans)
		exit()
print(ans)


import sys
import math
from functools import reduce
import bisect

def getN():
	return int(input())

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

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

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

def index(a, x):
	i = bisect.bisect_left(a, x)
	if i != len(a) and a[i] == x:
		return i
	return False
(n, x, y) = getNM()
arr = getList()
if x > y:
	print(n)
	exit()
count = 0
for a in arr:
	if a <= x:
		count += 1
print(count - count // 2)


from sys import stdin
import math

def get_ints():
	return list(map(int, stdin.readline().strip().split()))
(n, x, y) = get_ints()
a = get_ints()
if x > y:
	print(n)
	exit()
if x <= y:
	print(math.ceil(len([f for f in a if f <= x]) / 2))
	exit()


(n, x, y) = map(int, input().split())
seq = sorted(map(int, input().split()))
if x > y:
	print(n)
else:
	ans = 0
	for i in range(len(seq)):
		s = seq[i]
		if s <= x:
			s = 0
			ans += 1
			if i != n - 1:
				seq[i + 1] += y
				seq = sorted(seq)
		elif y >= x:
			break
	print(ans)


import math
from decimal import Decimal
import heapq

def na():
	n = int(input())
	b = [int(x) for x in input().split()]
	return (n, b)

def nab():
	n = int(input())
	b = [int(x) for x in input().split()]
	c = [int(x) for x in input().split()]
	return (n, b, c)

def dv():
	(n, m) = map(int, input().split())
	return (n, m)

def dva():
	(n, m) = map(int, input().split())
	a = [int(x) for x in input().split()]
	b = [int(x) for x in input().split()]
	return (n, m, b)

def eratosthenes(n):
	sieve = list(range(n + 1))
	for i in sieve:
		if i > 1:
			for j in range(i + i, len(sieve), i):
				sieve[j] = 0
	return sorted(set(sieve))

def nm():
	n = int(input())
	b = [int(x) for x in input().split()]
	m = int(input())
	c = [int(x) for x in input().split()]
	return (n, b, m, c)

def dvs():
	n = int(input())
	m = int(input())
	return (n, m)
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
	exit()
ans = 0
for i in a:
	if i <= x:
		ans += 1
print(ans // 2 + ans % 2)


import sys
import math

def read_int():
	return int(input().strip())

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

def read_string():
	return input().strip()

def read_string_list(delim=' '):
	return input().strip().split(delim)
(n, x, y) = read_int_list()
arr = read_int_list()
if x > y:
	print(n)
	sys.exit()
mini = 0
for a in arr:
	if a <= x:
		mini += 1
print(int(math.ceil(mini / 2)))


from collections import deque
import pdb
import heapq
from heapq import *
from pprint import pprint

def rI():
	return [int(i) for i in input().split()]
(n, x, y) = rI()
dat = rI()
if x > y:
	print(len(dat))
else:
	mtx = 0
	for i in dat:
		if i <= x:
			mtx += 1
	print((mtx + 1) // 2)


from sys import stdin, stdout
for _ in range(1):
	(n, x, y) = list(map(int, stdin.readline().split()))
	a = list(map(int, stdin.readline().split()))
	if x > y:
		print(n)
		continue
	less = 0
	for v in a:
		if v <= x:
			less += 1
	if less & 1:
		print(less // 2 + 1)
	else:
		print(less // 2)


(n, x, y) = [*map(int, input().split())]
a = [*map(int, input().split())]
b = a
c = []
d = []
if x > y:
	print(n)
else:
	for i in range(0, n):
		if a[i] > x:
			c.append(a[i])
		else:
			d.append(a[i])
	s = len(d)
	if s % 2 == 0:
		print(s // 2)
	else:
		print(s // 2 + 1)


(n, x, y) = map(int, input().split())
li = list(map(int, input().split()))
tf = [i > x for i in li]
if x > y:
	print(n)
else:
	l1 = tf.count(False)
	if l1 % 2 == 0:
		print(l1 // 2)
	else:
		print((l1 + 1) // 2)


import math
(n, x, y) = map(int, input().split())
d = len([_ for _ in map(int, input().split()) if _ <= x])
print(n if x > y else math.ceil(d / 2))


import math
nxy = input()
numeri = input()
l1 = list(map(int, nxy.rstrip().split()))
ai = list(map(int, numeri.rstrip().split()))
bi = sorted(ai)
n = l1[0]
x = l1[1]
y = l1[2]
cont = 1
if y >= x:
	accessibili = [i < x + 1 for i in bi]
	num = math.ceil(accessibili.count(True) / 2)
	print(num)
else:
	print(n)


(n, x, y) = map(lambda x: int(x), input().split())
c = map(int, input().strip().split())
c = list(c)
num = 0
if x > y:
	print(n)
else:
	for i in c:
		if i <= x:
			num += 1
	print((num + 1) // 2)


from sys import exit
(n, x, y) = map(int, input().split())
vec = list(map(int, input().split()))
if x > y:
	print(n)
	exit()
else:
	ans = 0
	for i in vec:
		ans += i <= x
	print(ans // 2 + (ans & 1))


(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
if x > y:
	print(n)
else:
	count = sum((1 for a in arr if a <= x))
	print(count - count // 2)


def solve():
	(n, x, y) = map(int, input().split(' '))
	a = list(map(int, input().split(' ')))
	if x > y:
		print(n)
	else:
		c = 0
		for elem in a:
			if elem <= x:
				c += 1
		print(c // 2 + c % 2)
solve()


from bisect import bisect_right as br
(n, x, y) = map(int, input().split())
lst = sorted(map(int, input().split()))
if x > y:
	print(n)
	exit()
print((br(lst, x) + 1) // 2)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	k = 1
	for (i, item) in enumerate(a):
		if item <= x:
			k += 1
	print(k // 2)


(n, x, y) = input().split()
n = int(n)
x = int(x)
y = int(y)
inp = input().split()
a = []
for i in range(n):
	a.append(int(inp[i]))
a.sort()
if x > y:
	print(n)
else:
	for j in range(10000):
		for i in range(n - 1):
			a[i] = max(0, a[i] - x)
			if a[i] > 0:
				a[i] += y
			else:
				a[i + 1] += y
		a[n - 1] = max(0, a[n - 1] - x)
		if a[n - 1] > 0:
			a[n - 1] += y
	ctr = 0
	for i in a:
		if i == 0:
			ctr += 1
	print(ctr)


import os
import sys
from io import BytesIO, IOBase
from types import GeneratorType

def bootstrap(f, stack=[]):

	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to
	return wrappedfunc
from collections import defaultdict
from math import sqrt
INF = pow(2, 63)

def isPrime(number):
	assert isinstance(number, int) and number >= 0, "'number' must been an int and positive"
	status = True
	if number <= 1:
		status = False
	for divisor in range(2, int(round(sqrt(number))) + 1):
		if number % divisor == 0:
			status = False
			break
	assert isinstance(status, bool), "'status' must been from type bool"
	return status

def prime_factors(n: int):
	i = 2
	factors = []
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.append(i)
	if n > 1:
		factors.append(n)
	return factors

def greatest_common_divisor(a: int, b: int) -> int:
	return abs(b) if a == 0 else greatest_common_divisor(b % a, a)

def solveb(n, tuparr):
	return -1
import math

def solve(n, x, y, arr):
	if x > y:
		print(n)
		return
	c = sum([1 for d in arr if y - x <= d <= x])
	c1 = sum([1 for d in arr if d < y - x])
	print(c1 + c // 2 + c % 2)

def main():
	[n, m, o] = list(map(int, input().strip().split()))
	arrn = list(map(int, input().strip().split()))
	solve(n, m, o, arrn)

def mainb():
	pass
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			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()
import sys

class ostream:

	def __lshift__(self, a):
		sys.stdout.write(str(a))
		return self
cout = ostream()
endl = '\n'

def readnumbers(zero=0):
	conv = ord if py2 else lambda x: x
	A = []
	numb = zero
	sign = 1
	i = 0
	s = sys.stdin.buffer.read()
	try:
		while True:
			if s[i] >= b'0'[0]:
				numb = 10 * numb + conv(s[i]) - 48
			elif s[i] == b'-'[0]:
				sign = -1
			elif s[i] != b'\r'[0]:
				A.append(sign * numb)
				numb = zero
				sign = 1
			i += 1
	except:
		pass
	if s and s[-1] >= b'0'[0]:
		A.append(sign * numb)
	return A
main()


(n, x, y) = map(int, input().split())
if x > y:
	print(n)
else:
	print((len([t for t in map(int, input().split()) if t <= x]) + 1) // 2)


(n, x, y) = map(int, input().split())
doors = 0
for i in input().split():
	if int(i) <= x:
		doors += 1
if x > y:
	print(n)
else:
	print(int(doors / 2) + doors % 2)


(n, x, y) = (int(x) for x in input().split())
a = [int(x) for x in input().split()]
if y < x:
	ans = n
else:
	ans = (len([ai for ai in a if ai <= x]) + 1) // 2
print(ans)


from bisect import bisect_right
(n, x, y) = [int(i) for i in input().split()]
if x > y:
	print(n)
	exit()
nums = sorted([int(i) for i in input().split()])
ind = bisect_right(nums, x) - 1
c = 0
while ind != -1:
	del nums[ind]
	n -= 1
	c += 1
	if n == 0:
		break
	nums[0] += y
	nums.sort()
	ind = bisect_right(nums, x) - 1
print(c)


(n, x, y) = input().split(' ')
n = int(n)
x = int(x)
y = int(y)
doors = input().split(' ')
doors_sum = 0
for i in doors:
	doors_sum += int(i)
if y >= x:
	cnt = 0
	for i in doors:
		if int(i) <= x:
			cnt += 1
	if cnt % 2 == 0:
		print(int(cnt / 2))
	else:
		print(int(cnt / 2) + 1)
elif x > y:
	print(n)


def main():
	(n, x, y) = map(int, input().split(' '))
	a = [int(c) for c in input().strip().split(' ')]
	if x > y:
		print(n)
		return

	def brk():
		zeroes_count = a.count(0)
		if zeroes_count == len(a):
			return True
		breakables = [(i, ai) for (i, ai) in enumerate(a) if ai > 0 and ai <= x]
		if len(breakables) > 0:
			max_hp_breakable_idx = max(breakables, key=lambda b: b[1])[0]
			a[max_hp_breakable_idx] = 0
			if zeroes_count + 1 == len(a):
				return True
			return False
		return True

	def rpr():
		breakables = [(i, ai) for (i, ai) in enumerate(a) if ai > 0 and ai <= x]
		if len(breakables) > 0:
			renderable_breakables = [(i, ai) for (i, ai) in breakables if ai + y > x]
			if len(renderable_breakables) > 0:
				min_hp_such_door_idx = min(renderable_breakables, key=lambda b: b[1])[0]
				a[min_hp_such_door_idx] += y
				return
		nonbreakables = [(i, ai) for (i, ai) in enumerate(a) if ai > 0 and ai > x]
		a[min(nonbreakables, key=lambda b: b[1])[0]] += y
	is_my_turn = True
	while True:
		if is_my_turn:
			if brk():
				print(a.count(0))
				return
		else:
			rpr()
		is_my_turn = not is_my_turn
main()


import sys
s = input().split(' ')
n = int(s[0])
x = int(s[1])
y = int(s[2])
doors = list(map(int, input().split(' ')))
if x > y:
	print(n)
	sys.exit(0)
p1 = 0
p2 = 0
for d in doors:
	if x >= d:
		p1 += 1
count = p1 // 2 + p1 % 2
print(count)


def main():
	line1 = input()
	(n, x, y) = [int(i) for i in line1.split()]
	num_vulnerable = 0
	if x > y:
		num_vulnerable = n
	else:
		line2 = input()
		num_vulnerable = len([i for i in line2.split() if int(i) <= x])
		num_vulnerable = (num_vulnerable + 1) // 2
	return num_vulnerable
print(main())


(n, x, y) = list(map(int, input().split()))
h = list(map(int, input().split()))
if x > y:
	print(n)
else:
	k = 0
	for i in h:
		if i <= x:
			k += 1
	print((k + 1) // 2)


(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
ans = 0
m = 0
d = 0
if x <= y:
	t = 0
	for i in a:
		if i <= x:
			t += 1
		else:
			break
	print(-(-t // 2))
else:
	print(n)


from sys import stdin, stdout
from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import *
input = stdin.readline
prin = stdout.write
from random import sample
from collections import Counter, deque
from math import sqrt, ceil, log2, gcd
mod = 10 ** 9 + 7

class DisjSet:

	def __init__(self, n):
		self.rank = [1] * n
		self.parent = [i for i in range(n)]

	def find(self, x):
		if self.parent[x] != x:
			self.parent[x] = self.find(self.parent[x])
		return self.parent[x]

	def union(self, x, y):
		xset = self.find(x)
		yset = self.find(y)
		if xset == yset:
			return
		if self.rank[xset] < self.rank[yset]:
			self.parent[xset] = yset
		elif self.rank[xset] > self.rank[yset]:
			self.parent[yset] = xset
		else:
			self.parent[yset] = xset
			self.rank[xset] = self.rank[xset] + 1

def f(arr, i, j, d, dist):
	if i == j:
		return
	nn = max(arr[i:j])
	for tl in range(i, j):
		if arr[tl] == nn:
			dist[tl] = d
			f(arr, i, tl, d + 1, dist)
			f(arr, tl + 1, j, d + 1, dist)

def ps(n):
	cp = 0
	lk = 0
	arr = {}
	while n % 2 == 0:
		n = n // 2
		lk += 1
	arr[2] = lk
	for ps in range(3, ceil(sqrt(n)) + 1, 2):
		lk = 0
		while n % ps == 0:
			n = n // ps
			arr.append(n)
			arr.append(ps ** (lk + 1))
			lk += 1
		arr[ps] = lk
	if n != 1:
		lk += 1
		arr[n] = lk
	return arr

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def factorials(n, r):
	slr = n
	dpr = r
	qlr = 1
	qs = 1
	mod = 10 ** 9 + 7
	for ip in range(n - r + 1, n + 1):
		qlr = qlr * ip % mod
	for ij in range(1, r + 1):
		qs = qs * ij % mod
	ans = qlr * modInverse(qs) % mod
	return ans

def modInverse(b):
	qr = 10 ** 9 + 7
	return pow(b, qr - 2, qr)
from types import GeneratorType

def iterative(f, stack=[]):

	def wrapped_func(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		to = f(*args, **kwargs)
		while True:
			if type(to) is GeneratorType:
				stack.append(to)
				to = next(to)
				continue
			stack.pop()
			if not stack:
				break
			to = stack[-1].send(to)
		return to
	return wrapped_func

def power(arr):
	listrep = arr
	subsets = []
	for i in range(2 ** len(listrep)):
		subset = []
		for k in range(len(listrep)):
			if i & 1 << k:
				subset.append(listrep[k])
		subsets.append(subset)
	return subsets

def dis(xa, ya, xb, yb):
	return sqrt((xa - xb) ** 2 + (ya - yb) ** 2)

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

def ilist():
	return [int(x) for x in input().strip().split()]

def outstrlist(array: list) -> str:
	array = [str(x) for x in array]
	return ' '.join(array)

def islist():
	return list(map(str, input().split().rstrip()))

def outfast(arr: list) -> str:
	ss = ''
	for ip in arr:
		ss += str(ip) + ' '
	return prin(ss)

def pda(n):
	list = []
	for i in range(1, int(sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				list.append(i)
			else:
				list.append(int(n / i))
				list.append(i)
	return list
t = 1
for jj in range(t):
	(n, x, y) = ilist()
	arr = ilist()
	arr.sort()
	if x > y:
		print(n)
	else:
		c = 0
		for i in range(n):
			if arr[i] <= x:
				c += 1
		print(ceil(c / 2))


(n, x, y) = map(int, input().split())
arr = [int(i) for i in input().split()]
ans = 0
if x <= y:
	count = 0
	for a in arr:
		if a <= x:
			count += 1
	ans = (count + 1) // 2
	print(ans)
else:
	print(len(arr))


from sys import stdin
(n, x, y) = map(int, input().split())
l = list(map(int, stdin.readline().split()))
if x > y:
	print(len(l))
else:
	num = len([1 for i in l if i <= x])
	print((num + 1) // 2)


(a, b, c) = list(map(int, input().split()))
p = list(map(int, input().split()))
jam = []
if b > c:
	print(a)
else:
	for it in p:
		if it <= b:
			jam.append(it)
	jam.sort(reverse=True)
	s = 0
	lo = 0
	kj = 0
	while jam != list() and lo != 1:
		lo = 1
		if s == 0:
			for it in jam:
				if it <= b:
					x = jam.index(it)
					jam.remove(jam[x])
					kj += 1
					lo = 0
					break
			s = 1
		else:
			for it in jam:
				if it <= b:
					x = jam.index(it)
					jam[x] += c
					break
			s = 0
			lo = 0
	print(kj)


(n, x, y) = map(int, input().split())
a = [int(i) for i in input().split()]
if x > y:
	print(n)
	quit()
elif x <= y:
	n = sum(map(lambda t: t <= x, a))
	print(-(-n // 2))


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
l.sort(reverse=True)
if x > y:
	print(n)
else:
	ans = 0
	while l and l[-1] <= x:
		ans += 1
		l.pop()
		if l:
			l[-1] += y
			l.sort(reverse=True)
	print(ans)


import sys
import bisect
input = sys.stdin.readline
ins = lambda : input().rstrip()
ini = lambda : int(input().rstrip())
inm = lambda : map(int, input().rstrip().split())
inl = lambda : list(map(int, input().split()))
out = lambda x, s='\n': print(s.join(map(str, x)))
(n, x, y) = inm()
a = sorted(inl())
if x > y:
	print(n)
else:
	ans = bisect.bisect_right(a, x)
	print((ans + 1) // 2)


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter
from itertools import combinations as comb
from itertools import permutations as permutate
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
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))
from types import GeneratorType

def iterative(f, stack=[]):

	def wrapped_func(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		to = f(*args, **kwargs)
		while True:
			if type(to) is GeneratorType:
				stack.append(to)
				to = next(to)
				continue
			stack.pop()
			if not stack:
				break
			to = stack[-1].send(to)
		return to
	return wrapped_func
mod = 1000000007

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def zerolist(n):
	return [0] * n

def nextline():
	out('\n')

def testcase(t):
	for pp in range(t):
		solve(pp)

def printlist(a):
	for p in range(0, len(a)):
		out(str(a[p]) + ' ')

def google(p):
	print('Case #' + str(p) + ': ', end='')

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

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 ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def solve(case):
	(n, x, y) = sep()
	a = lis()
	if x > y:
		print(n)
		return
	else:
		cnt = 0
		for i in range(n):
			if a[i] <= x:
				cnt += 1
		if cnt == 0:
			print(0)
		else:
			print(ceil(cnt / 2))
testcase(1)


from math import *
(n, x, y) = map(int, input().split())
b = list(map(int, input().split()))
if y >= x:
	print(ceil(sum((i <= x for i in b)) / 2))
else:
	print(n)


(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
if x > y:
	print(n)
else:
	less = []
	for i in range(n):
		if arr[i] <= x:
			less.append(arr[i])
	less.sort(reverse=True)
	cnt = 0
	while True:
		removed = -1
		for i in range(len(less)):
			if less[i] <= x:
				cnt += 1
				removed = i
				for j in range(len(less) - 1, i, -1):
					if less[j] <= x:
						less[j] += y
						break
				else:
					less[-1] += y
				break
		if removed == -1:
			break
		else:
			del less[removed]
			less.sort()
	print(cnt)


def read(type=1):
	if type:
		file = open('input.dat', 'r')
		line = int(file.readline())
		file.close()
	else:
		line = list(map(int, input().strip().split()))
		n = line[0]
		x = line[1]
		y = line[2]
		line = list(map(int, input().strip().split()))
	return (n, x, y, sorted(line, reverse=True))

def solve():
	sol = 0
	for i in range(len(a)):
		if a[len(a) - 1 - i] + y > x:
			pos = len(a) - 1 - i
			pos = len(a) - 1 - i
			break
	for i in range(len(a)):
		if a[i] <= x:
			sol += 1
			a[pos] += y
			pos -= 1
	if x > y:
		return n
	else:
		return sol
(n, x, y, a) = read(0)
sol = solve()
print(sol)


(n, x, y) = [int(x) for x in input().split()]
dver = [int(x) for x in input().split()]
if x > y:
	print(n)
else:
	counter = 0
	for item in dver:
		if item <= x:
			counter += 1
	if counter % 2 == 0:
		print(counter // 2)
	else:
		print(counter // 2 + 1)


(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
if x > y:
	print(n)
elif x == y:
	count1 = 0
	count2 = 0
	for i in range(n):
		if arr[i] <= x:
			count1 += 1
		elif arr[i] <= 2 * x:
			count2 += 1
	print((count1 + 1) // 2)
else:
	count1 = 0
	for i in range(n):
		if arr[i] <= x:
			count1 += 1
	print((count1 + 1) // 2)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
flag = True
count = 0
z = 0
if x > y:
	z = 1
	count = n
else:
	for i in a:
		if i <= x:
			count += 1
if flag & z == 1:
	print(count)
else:
	print(int((count + 1) / 2))


[a, b, c] = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
if b > c:
	print(a)
else:
	count = 0
	for i in l:
		if i <= b:
			count += 1
	if count % 2 == 0:
		print(int(count / 2))
	else:
		print(int(count / 2) + 1)


import math
for t in range(1):
	(n, x, y) = map(int, input().split())
	arr = list(map(int, input().split()))
	if x > y:
		print(n)
		continue
	else:
		less = 0
		for i in range(n):
			ele = arr[i]
			if ele <= x:
				less += 1
		print(math.ceil(less / 2))


from sys import stdin
from collections import Counter
from itertools import zip_longest
inp = [stdin.readline().split(' ') for _ in range(2)]
(n, x, y) = map(int, inp[0])
a = [int(el) for el in inp[1]]
res = 0
if x > y:
	a = [0] * n
	res = n
else:
	insec_doors = len([1 for el in a if el <= x])
	res = insec_doors // 2 + insec_doors % 2
print(res)


(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
if x > y:
	print(n)
	exit(0)
else:
	low = 0
	for h in a:
		if h <= x:
			low += 1
	print(low // 2 + low % 2)


from collections import Counter
(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
if x > y:
	print(n)
else:
	p = len([0 for i in l if i <= x])
	if p % 2 == 0:
		print(p // 2)
	else:
		print(p // 2 + 1)


from sys import stdin, stdout
from math import sin, tan, cos, pi, atan2, sqrt, acos, atan, factorial
from random import randint
(n, x, y) = map(int, stdin.readline().split())
values = list(map(int, stdin.readline().split()))
if x > y:
	stdout.write(str(n))
else:
	v = sum(map(lambda v: int(v <= x), values))
	stdout.write(str(v // 2 + (v & 1)))


(n, x, y) = map(int, input().split())
doors = list(map(int, input().split()))
if x > y:
	print(n)
else:
	res = len([i for i in doors if i <= x])
	print((res + 1) // 2)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
b = [k for k in a if k <= x]
l = len(b)
num = int(l / 2) + l % 2
if x > y:
	print(n)
else:
	print(num)


(n, x, y) = map(int, input().split())
l = [int(i) for i in input().split()]
if x > y:
	print(n)
else:
	l.sort()
	c = 0
	for i in l:
		if i <= x:
			c += 1
		else:
			break
	x = c // 2
	if c % 2 == 1:
		x += 1
	print(x)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
cnt = 0
for a in l:
	if a <= x:
		cnt += 1
if x > y:
	print(n)
else:
	print((cnt + 1) // 2)


import sys, bisect
(n, x, y) = map(int, sys.stdin.readline().split())
arr = list(map(int, sys.stdin.readline().split()))
ans = 0
if x > y:
	print(n)
else:
	while True:
		arr.sort()
		idx = -1
		temp = []
		for i in range(n):
			if arr[i] and arr[i] <= x:
				temp.append(i)
		temp.sort(key=lambda x: -arr[x])
		if not temp:
			break
		else:
			ans += 1
			arr[temp[0]] = 0
		for i in range(n):
			if arr[i] != 0:
				arr[i] += y
				break
	print(ans)


from math import ceil
(n, x, y) = map(int, input().split())
lst = list(map(int, input().split()))
if x > y:
	print(n)
else:
	cnt = len(list(filter(lambda c: c <= x, lst)))
	print(ceil(cnt / 2))


from math import ceil, floor, gcd
from collections import deque as queue

def decToBin(number, size=64):
	return bin(number)[2:].zfill(size)

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

def binarySearch(arr, l, r, x):
	if r >= l:
		mid = l + (r - l) / 2
		if arr[mid] == x:
			return mid
		elif arr[mid] > x:
			return binarySearch(arr, l, mid - 1, x)
		else:
			return binarySearch(arr, mid + 1, r, x)
	else:
		return -1
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
if x > y:
	print(n)
else:
	p = 0
	for i in a:
		if i <= x:
			p += 1
	print(ceil(p / 2))


import math
mod = 1000000007
(n, x, y) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
if x > y:
	print(n)
else:
	c = 0
	for i in range(n):
		if a[i] <= x:
			c += 1
	print((c + 1) // 2)


f = lambda : map(int, input().split())
(n, x, y) = f()
cnt = 0
for i in f():
	if i <= x:
		cnt += 1
print(n if x > y else (cnt + 1) // 2)


import sys
I = lambda : map(int, sys.stdin.readline().split())
(n, x, y) = I()
li = list(map(int, input().split()))
c = 0
if x > y:
	exit(print(n))
for i in li:
	if i <= x:
		c += 1
exit(print((c + 1) // 2))


(n, x, y) = map(int, input().split())
array = list(map(int, input().split()))
if x > y:
	print(n)
else:
	count = 0
	h = 1
	for el in array:
		if el <= x and h == 1:
			count += 1
			h = 2
		elif el <= x and h == 2:
			h = 1
	print(count)


import sys
inf = float('inf')
mod = 1000000007

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

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

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

def main():
	(n, x, y) = get_ints()
	arr = get_array()
	if x > y:
		print(n)
	else:
		count = 0
		for i in arr:
			if i <= x:
				count += 1
		count -= 1
		from math import ceil
		print(1 + count // 2)
main()


from bisect import *
(n, x, y) = map(int, input().split())
l = sorted(list(map(int, input().split())))
if x > y:
	print(n)
	exit(0)
print(int((bisect(l, x) + 1) / 2))


(n, x, y) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
N = n
if x > y:
	print(n)
	quit()
else:
	a.sort()
	ind = 0
	count = 0
	while ind < n and a[ind] <= x:
		ind += 1
	while n > 0 and ind > 0:
		a.pop(ind - 1)
		n -= 1
		if n == 0:
			print(N)
			quit()
		a[0] += y
		a.sort()
		count += 1
		ind = 0
		n = len(a)
		while ind < n and a[ind] <= x:
			ind += 1
	print(count)


(n, x, y) = input().split()
n = int(n)
x = int(x)
y = int(y)
l = [int(x) for x in input().split()]
l.sort()
count_a = 0
for i in range(n):
	if l[i] <= x:
		count_a += 1
if x > y:
	print(n)
else:
	print(count_a % 2 + count_a // 2)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

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

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

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

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def main():
	(n, x, y) = LI()
	a = LI()
	if x > y:
		return n
	c = len([b for b in a if b <= x])
	return (c + 1) // 2
print(main())


(n, x, y) = map(int, input().split())
doors = list(map(int, input().split()))
door_can_broke = 0
if x > y:
	print(len(doors))
else:
	doors.sort()
	while door_can_broke <= n - 1 and doors[door_can_broke] <= x:
		door_can_broke += 1
	if door_can_broke / 2 == door_can_broke // 2:
		print(door_can_broke // 2)
	else:
		print(door_can_broke // 2 + 1)


def C():
	(n, x, y) = map(int, input().split())
	doors = [int(x) for x in input().split()]
	if y >= x:
		ans = 0
		for d in doors:
			if d <= x:
				ans += 1
		print((ans + 1) // 2)
		return
	print(n)
C()


nps = list(map(int, input().split()))
n = nps[0]
p = nps[1]
s = nps[2]
lst = list(map(int, input().split()))
if p > s:
	print(n)
else:
	total = 0
	for i in lst:
		if i <= p:
			total += 1
	print(total - total // 2)


lis1 = input().split(' ')
lis2 = input().split(' ')
n = int(lis1[0])
x = int(lis1[1])
y = int(lis1[2])
dur = []
for i in range(n):
	dur.append(int(lis2[i]))
if x > y:
	print(n)
else:
	broken = 0
	for i in range(n - 1):
		dur.sort()
		if dur[i] <= x:
			broken += 1
			dur[i + 1] += y
		else:
			break
	if dur[n - 1] <= x:
		broken += 1
	print(broken)


import sys, os
from io import BytesIO, IOBase
import collections, itertools, bisect, heapq, math, string
from decimal import *
BUFSIZE = 8192
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')

def main():
	(n, x, y) = map(int, input().split())
	a = list(map(int, input().split()))
	if x > y:
		print(n)
	else:
		cnt = 0
		for b in a:
			if b <= x:
				cnt += 1
		print(math.ceil(cnt / 2))
main()


from sys import stdin

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

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

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

def si():
	return stdin.readline()
(n, x, y) = mi()
a = li()
if x > y:
	print(n)
	exit()
p = 0
for i in a:
	if i <= x:
		p += 1
print((p + 1) // 2)


import math
import sys
input = sys.stdin.readline
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	c = 0
	for i in a:
		if i <= x:
			c += 1
	print(math.ceil(c / 2))


from math import ceil
(n, a, b) = map(int, input().strip().split())
l = [int(x) for x in input().strip().split()]
if a > b:
	print(n)
else:
	c = sum([1 for x in l if x <= a])
	print(int(ceil(c / 2)))


import string
import math

def main():
	(n, x, y) = map(int, input().split())
	tab = list(map(int, input().split()))
	inc = 0
	tab.sort()
	while len(tab) > 0 and x >= tab[0]:
		tab.pop(0)
		if len(tab) > 0:
			tab[0] += y
			tab.sort()
		inc += 1
	n = len(tab)
	if y >= x:
		print(inc)
		return
	x -= y
	nb_tours = inc
	while nb_tours < 10 ** 100 and len(tab) > 0:
		nb_tours += math.ceil(tab[0] / x)
		inc += 1
		tab.pop(0)
	print(inc)
main()


from math import ceil
inp = lambda : map(int, input().split())
(n, x, y) = inp()
c = 0
arr = [int(x) for x in input().split()]
for i in arr:
	if i <= x:
		c += 1
if x > y:
	print(n)
else:
	print(ceil(c / 2))


from math import *
(n, x, y) = map(int, input().split())
v = [int(i) for i in input().split()]
if x > y:
	print(n)
else:
	print(ceil(len([i for i in v if i <= x]) / 2))


def main():
	(n, x, y) = map(int, input().split())
	a = list(map(int, input().split()))
	if x > y:
		print(n)
	else:
		count = 0
		for k in a:
			if k <= x:
				count += 1
		print((count + 1) // 2)
main()


def get_ints():
	return list(map(int, input().split()))
(n, x, y) = get_ints()
l = get_ints()
if x > y:
	print(n)
else:
	print((sum([i <= x for i in l]) + 1) // 2)


from math import ceil
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if (x - y) * 10 ** 100 > sum(a):
	print(n)
else:
	t = sum([1 for i in a if i <= x])
	print(ceil(t / 2))


from math import ceil
(n, x, y) = [int(i) for i in input().split()]
doors = [int(i) for i in input().split()]
doors.sort()
A = y >= x
total_time = 10 ** 100
time = 0
removed_doors = 0
while doors:
	if x > y:
		if x >= doors[0]:
			if time + 1 < total_time:
				time += 1
				removed_doors += 1
				doors = doors[1:]
				if len(doors) > 0:
					doors[0] += y
				doors.sort()
		elif time + ceil(doors[0] / (x - y)) < total_time:
			time += ceil(doors[0] / (x - y))
			removed_doors += 1
			doors = doors[1:]
			if len(doors) > 0:
				doors[0] += y
				doors.sort()
		else:
			break
	elif doors[0] <= x:
		removed_doors += 1
		doors = doors[1:]
		if len(doors) > 0:
			doors[0] += y
			doors.sort()
	else:
		doors = []
		break
print(removed_doors)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	b = []
	for z in a:
		if z <= x:
			b.append(z)
	print((len(b) + 1) // 2)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if y - x >= 0:
	ans = 0
	for elem in a:
		if elem <= x:
			ans += 1
	print((ans + 1) // 2)
else:
	print(n)


(n, x, y) = map(int, input().split())
if x > y:
	print(n)
else:
	tot = 0
	for i in map(int, input().split()):
		if x >= i:
			tot += 1
	print(tot + 1 >> 1)


(n, x, y) = map(int, input().split())
m = [int(i) for i in input().split()]
z = 0
for i in range(n):
	if m[i] <= x:
		z += 1
if x > y:
	print(n)
elif z % 2 == 0:
	print(z // 2)
else:
	print(z // 2 + 1)


ar = input()
ll = list(map(int, ar.split(' ')))
n = ll[0]
x = ll[1]
y = ll[2]
arr = input()
l = list(map(int, arr.split(' ')))
if x > y:
	print(n)
else:
	t = 0
	for i in range(n):
		if l[i] <= x:
			t += 1
	if t % 2 == 0:
		print(int(t / 2))
	else:
		print(int(t / 2) + 1)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	print((len([ai for ai in a if ai <= x]) + 1) // 2)


def solve(n, x, y, values):
	if x > y:
		return n
	values = sorted(filter(lambda v: v <= x, values))
	answer = 0
	while len(values) > 0:
		answer += 1
		values.pop()
		if len(values) > 0:
			values.pop(0)
	return answer
(n, x, y) = map(int, input().strip().split(' '))
values = list(map(int, input().strip().split(' ')))
print(solve(n, x, y, values))


import sys
line = sys.stdin.readline().strip().split()
n = int(line[0])
x = int(line[1])
y = int(line[2])
a = list(map(int, sys.stdin.readline().strip().split()))
d = len(a)
s = []
if x > y:
	print(d)
else:
	j = 0
	for i in a:
		if i <= x:
			j = j + 1
	if j % 2 == 0:
		print(j // 2)
	else:
		print(j // 2 + 1)


a = input().split()
b = input().split()
b = [int(b_i) for b_i in b]
(n, x, y) = (int(a[0]), int(a[1]), int(a[2]))
i = 0
max_steps = 10 ** 100
can_play = True
zeros = 0
k = 0
if x > y:
	print(n)
else:
	while can_play and k < n and (i < max_steps):
		b.sort()
		if b[k] <= x:
			b[k] = 0
			k += 1
			zeros += 1
		else:
			can_play = False
		if k < n:
			b[k] += y
		i += 1
	print(zeros)


from math import ceil, floor, log10, log2
(n, x, y) = list(map(int, input().split()))
nums = list(map(int, input().split()))
got = 0
for i in nums:
	if i <= x:
		got += 1
if x > y:
	print(len(nums))
else:
	print(ceil(got / 2))


(n, x, y) = map(int, input().split())
(*arr,) = map(int, input().split())
if x > y:
	print(n)
	exit()
print((len([0 for i in arr if i <= x]) + 1) // 2)


(n, x, y) = map(int, input().split())
h = [int(i) for i in input().split()]
if x > y:
	print(len(h))
else:
	h = list(filter(lambda xi: xi <= x, h))
	print((len(h) + len(h) % 2) // 2)


import math

def input_():
	(n, x, y) = [int(i) for i in input().split()]
	a = [int(i) for i in input().split()]
	return (n, x, y, a)
(n, x, y, a) = input_()
broken_count = 0

class game:

	def __init__(self):
		self.a = a
		self.broken_count = 0

	def break_(self, i):
		self.a[i] = max(0, self.a[i] - x)
		if self.a[i] == 0:
			self.broken_count += 1
			self.a.remove(i)

	def repair(self, i):
		self.a[i] = self.a[i] + y
		self.a.sort()

def go():
	a.sort()
	if x <= y:
		count = 0
		for i in a:
			if i > x:
				break
			else:
				count += 1
		print(math.ceil(count / 2))
	else:
		print(n)
go()


from bisect import bisect_right as br
from bisect import bisect_left as bl
from collections import defaultdict
from itertools import combinations
import functools
import sys
import math
MAX = sys.maxsize
MAXN = 10 ** 6 + 10
MOD = 10 ** 9 + 7

def isprime(n):
	n = abs(int(n))
	if n < 2:
		return False
	if n == 2:
		return True
	if not n & 1:
		return False
	for x in range(3, int(n ** 0.5) + 1, 2):
		if n % x == 0:
			return False
	return True

def mhd(a, b, x, y):
	return abs(a - x) + abs(b - y)

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

def charIN():
	return sys.stdin.readline().strip().split()

def ncr(n, k):
	res = 1
	c = [0] * (k + 1)
	c[0] = 1
	for i in range(1, n + 1):
		for j in range(min(i, k), 0, -1):
			c[j] = (c[j] + c[j - 1]) % MOD
	return c[k]
(n, x, y) = numIN()
a = list(numIN())
if x > y:
	print(n)
else:
	a.sort()
	z = br(a, x)
	print(math.ceil(z / 2))


(n, x, y) = map(int, input().split())
l = [int(n) for n in input().split()]
l = sorted(l)
if x > y:
	print(n)
elif x <= y:
	index = -1
	for i in l:
		if i <= x:
			index += 1
	l = l[:index + 1]
	print(len(l) - len(l) // 2)


(n, x, y) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
if x > y:
	print(n)
else:
	c = 0
	for ele in a:
		if ele <= x:
			c += 1
	total = n - c
	total += c // 2
	print(n - total)


def line():
	return map(int, input().split())
from bisect import insort
(n, x, y) = line()
a = list(line())
c = 0
if y >= x:
	a = sorted(a)
	while a and a[0] <= x:
		c += 1
		del a[0]
		if a:
			b = a.pop(0)
			insort(a, b + y)
else:
	c = len(a)
print(c)


(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	ctr = 0
	for num in a:
		if num <= x:
			ctr += 1
	print((ctr + 1) // 2)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	c = 0
	while min(a) <= x:
		for i in a:
			if i <= x:
				c += 1
				a.remove(i)
				if not a:
					print(c)
					exit()
				for j in range(len(a)):
					if a[j] <= x:
						a[j] += y
						break
				break
	print(c)


from bisect import bisect_right

def solve(a, n, x, y):
	if x > y:
		return n
	p = bisect_right(a, x)
	return (p + 1) // 2
(n, x, y) = map(int, input().split())
a = sorted(list(map(int, input().split())))
print(solve(a, n, x, y))


import math
(n, x, y) = [int(z) for z in input().split()]
a = [int(z) for z in input().split()]
c = 0
if y < x:
	print(n)
else:
	for ele in a:
		if ele <= x:
			c += 1
	print(math.ceil(c / 2))


(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
if x > y:
	print(n)
else:
	ans = 0
	p = []
	for i in a:
		if i <= x:
			p.append(i)
	p.sort(key=lambda x: -x)
	ans = 0
	s = [0] * len(p)
	for i in range(len(p)):
		if p[i] + s[i] * y <= x:
			ans += 1
			if i + 1 < len(p):
				s[i + 1] = s[i]
		else:
			continue
		if i + 1 < len(p):
			s[i + 1] += 1
	print(ans)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
smaller_count = sum([1 for k in a if k <= x])
if x > y:
	print(n)
else:
	print((smaller_count + 1) // 2)


(n, x, y) = map(int, input().split(' '))
a = tuple(map(int, input().split(' ')))
sum = 0
if x > y:
	print(n)
else:
	for i in a:
		if i <= x:
			sum += 1
	print((sum + 1) // 2)


nxy = input().split()
(n, x, y) = (int(nxy[0]), int(nxy[1]), int(nxy[2]))
a = input().split()
a = list(map(int, a))
if x > y:
	print(len(a))
else:
	sum = 0
	a = sorted(a)
	i = 0
	while i < n and a[i] <= x:
		i += 1
	i -= 1
	while i >= 0:
		sum += 1
		if i - 1 >= 0 and a[i - 1] + y > x:
			i -= 2
		else:
			i -= 1
	print(sum)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
result = n if x > y else (sum((d <= x for d in a)) + 1) // 2
print('{}'.format(result))


(n, x, y) = map(int, input().split())
a = [int(j) for j in input().split()]
nLX = 0
for e in a:
	if e <= x:
		nLX += 1
if y >= x:
	print((nLX + 1) // 2)
else:
	print(n)


digl = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
mod = 10 ** 9 + 7
(n, x, y) = f()
l = sorted(il())
d = 0
if x > y:
	print(n)
else:
	for i in range(0, n, 2):
		if l[i] <= x:
			d += 1
	print(d)


import math
(n, x, y) = map(int, input().rstrip().split(' '))
ar = list(map(int, input().rstrip().split(' ')))
count = 0
if y < x:
	print(n)
else:
	for i in ar:
		if i <= x:
			count += 1
	print(math.ceil(count / 2))


from math import ceil
(n, x, y) = [int(s) for s in input().split(' ')]
a = [int(s) for s in input().split(' ')]
if x > y:
	print(n)
else:
	res = 0
	for el in a:
		if el <= x:
			res = res + 1
	print(ceil(res / 2))


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x > y:
	print(n)
elif x <= y:
	insecure_doors = 0
	for e in a:
		if e <= x:
			insecure_doors += 1
	print(int((insecure_doors + 1) / 2))


tmp = input().split()
n = int(tmp[0])
x = int(tmp[1])
y = int(tmp[2])
tmp = input().split()
arr = []
for i in range(n):
	arr.append(int(tmp[i]))
if x > y:
	print(n)
	exit(0)
arr.sort()
total = 0
for i in range(n):
	if arr[i] > x:
		break
	if i % 2 == 0:
		arr[i] = 0
arr.sort()
isBool = False
for i in range(n):
	if arr[i] != 0:
		print(i)
		isBool = True
		break
if not isBool:
	print(n)


(n, x, y) = map(int, input().split())
lst = [int(x) for x in input().split()]
if x > y:
	print(n)
else:
	c = sum(map(lambda i: i <= x, lst))
	if c % 2 == 0:
		print(c // 2)
	else:
		print(c // 2 + 1)


def f(n, x, y, l):
	if x > y:
		return n
	possible = [el for el in l if el <= x]
	if len(possible) % 2 == 0:
		return len(possible) / 2
	else:
		return int(len(possible) / 2) + 1
row = input().split(' ')
n = int(row[0])
x = int(row[1])
y = int(row[2])
l = input().split(' ')
l = [int(el) for el in l]
output = f(n, x, y, l)
print(str(int(output)))


from bisect import bisect_right
(N, X, Y) = map(int, input().split())
aN = list(map(int, input().split()))
aN.sort()
weaks = bisect_right(aN, X)
if X <= Y:
	print(-(-weaks // 2))
else:
	print(len(aN))


l = [int(x) for x in input().split()]
n = l[0]
counter = 0
(x, y) = l[1:]
l = [int(x) for x in input().split()]
if x > y:
	print(n)
else:
	for i in l:
		if i <= x:
			counter += 1
	if counter % 2 == 0:
		print(int(counter / 2))
	else:
		print(int(counter / 2) + 1)


from math import *
(n, x, y) = map(int, input().split())
inp = list(map(int, input().split()))
if x > y:
	print(n)
else:
	cnt = 0
	for i in inp:
		if x >= i:
			cnt += 1
	print(ceil(cnt / 2))


import math
(n, x, y) = map(int, input().strip().split())
arr = list(map(int, input().strip().split()))
arr = sorted(arr)
if x > y:
	print(n)
elif x < y:
	c = 0
	for i in range(n):
		if arr[i] <= x:
			c += 1
	print(math.ceil(c / 2))
else:
	c = 0
	for i in range(n):
		if arr[i] <= x:
			c += 1
	print(math.ceil(c / 2))