import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.math.BigInteger;
import java.time.chrono.MinguoChronology;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Queue;

import javax.lang.model.element.ModuleElement.RequiresDirective;
import javax.swing.plaf.basic.BasicInternalFrameTitlePane.MaximizeAction;

import java.io.BufferedWriter;
import java.io.IOException;

/*

95 999999999999999 1

 */

public class Main
{
	static long a,b,c,d,e,f,t,l,r,v,n,m,k,x,y,res=0,len,pow;
	static StringBuilder sb,sb1,sb2;
	static String s;
	static long ar[] = new long[100009];
	static long cumu[] = new long[100009];
	static int dis[][] = new int[9][9];
	//static long cumu[] = new long[150009];
	static ArrayList<Long> vi = new ArrayList<>();
	boolean fl = true;

	public static void main(String[] args)throws IOException
	{
		MainFastScan scanner = new MainFastScan();
		MainFastPrint printer = new MainFastPrint();

		n = scanner.nextLong();
		long ami = scanner.nextLong();
		long salvik = scanner.nextLong();
		long cnt = 0;
		for(int i=0; i<n; i++)
		{
			x = scanner.nextLong();
			if(x<=ami) cnt++;
		}

	//	System.out.println(cnt);

		if(ami>salvik)
		{
			res = n;
		}
		else
		{
			if(cnt%2==0) res = cnt/2;
			else res = (cnt/2)+1;
		}

		printer.print(Long.toString(res));
		printer.print("\n");
		printer.close();
	}
}

class MainFastPrint
{
	private final BufferedWriter bw;
	public MainFastPrint(){bw=new BufferedWriter(new OutputStreamWriter(System.out));}
	public void print(String str)throws IOException{bw.append(str);}
	public void printLine(String str)throws IOException{print(str); bw.append("\n");}
	public void close()throws IOException{bw.close();}
	public void flush() throws IOException {bw.flush();}
}

class MainFastScan
{
	private byte[] buf=new byte[1024];
	private int index;
	private InputStream in;
	private int total;
	public MainFastScan()
	{
		in=System.in;
	}
	public int scan()throws IOException
	{
		if(total<0)
			throw new InputMismatchException();
		if(index>=total)
		{
			index=0;
			total=in.read(buf);
			if(total<=0)
				return -1;
		}
		return buf[index++];
	}
	public int nextInt()throws IOException
	{
		int integer=0;
		int n=scan();
		while(isWhiteSpace(n)) n=scan();
		int neg=1;
		if(n=='-')
		{
			neg=-1;
			n=scan();
		}
		while(!isWhiteSpace(n))
		{
			if(n>='0'&&n<='9')
			{
				integer*=10;
				integer+=n-'0';
				n=scan();
			}
			else throw new InputMismatchException();
		}
		return neg*integer;
	}

	public long nextLong()throws IOException
	{
		long res=0;
		int n = scan();
		while(isWhiteSpace(n)) n=scan();
		int neg=1;
		if(n=='-')
		{
			neg=-1;
			n=scan();
		}
		while(!isWhiteSpace(n))
		{
			if(n>='0'&&n<='9')
			{
				res *= 10;
				res += n-'0';
				n=scan();
			}
			else throw new InputMismatchException();
		}
		return neg*res;
	}

	public double nextDouble()throws IOException
	{
		double doub=0;
		int n=scan();
		while(isWhiteSpace(n)) n=scan();
		int neg=1;
		if(n=='-')
		{
			neg=-1;
			n=scan();
		}
		while(!isWhiteSpace(n)&&n!='.')
		{
			if(n>='0'&&n<='9')
			{
				doub*=10;
				doub+=n-'0';
				n=scan();
			}
			else throw new InputMismatchException();
		}
		if(n=='.')
		{
			n=scan();
			double temp=1;
			while(!isWhiteSpace(n))
			{
				if(n>='0'&&n<='9')
				{
					temp/=10;
					doub+=(n-'0')*temp;
					n=scan();
				}
				else throw new InputMismatchException();
			}
		}
		return doub*neg;
	}
	public String nextWord()throws IOException
	{
		StringBuilder sb=new StringBuilder();
		int n=scan();
		while(isWhiteSpace(n)) n=scan();
		while(!isWhiteSpace(n))
		{
			sb.append((char)n);
			n=scan();
		}
		return sb.toString();
	}
	public String nextLine()throws IOException
	{
		StringBuilder sb=new StringBuilder();
		int n=scan();
		while(isWhiteSpaceLine(n)) n=scan();
		while(!isWhiteSpaceLine(n))
		{
			sb.append((char)n);
			n=scan();
		}
		return sb.toString();
	}
	private boolean isWhiteSpace(int n)
	{
		if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
			return true;
		return false;
	}
	private boolean isWhiteSpaceLine(int n)
	{
		if(n=='\n'||n=='\r'||n=='\t'||n==-1)
			return true;
		return false;
	}
}


import java.io.File;
import java.io.FileNotFoundException;
    import java.util.*;
import javafx.util.Pair;

   public class Main {

    public static void main(String[] args) throws FileNotFoundException {
//        File f = new File("input.txt");
        Scanner input = new Scanner(System.in);
       int n = input.nextInt();
       int x = input.nextInt();
       int y = input.nextInt();
       int a[] = new int[n];
       int count=0;
        for (int i = 0; i < n; i++) {
            a[i] = input.nextInt();
            if(a[i]<=x)
                count++;
        }
       if(x>y)
       {
           System.out.println(n);
       }
       else
       {
           if(count%2==0)
           {
               System.out.println(count/2);
           }
           else
               System.out.println(count/2+1);
       }

    }
}


import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class Solution {

	public static void main(String[] args) {

		/*
		 *
		 */
		Scanner scan = new Scanner(System.in);

		int t= scan.nextInt();
		int x=scan.nextInt();
		int y=scan.nextInt();

		int[] arr= new int[t];
		int less=0;
		for(int i=0;i<t;i++) {
			arr[i]=scan.nextInt();
			if(arr[i]<=x) less++;
		}
		int ans=0;
		if(x>y) ans=t;
		else {
			if(less%2==0) ans=less/2;
			else ans=(less/2)+1;

		}
		System.out.println(ans);
		scan.close();

	}

	/*
	 * static final Random random=new Random();
	 *
	 * static void ruffleSort(int[] a) { int n=a.length;//shuffle, then sort for
	 * (int i=0; i<n; i++) { int oi=random.nextInt(n), temp=a[oi]; a[oi]=a[i];
	 * a[i]=temp; } Arrays.sort(a); }
	 */

}


import java.io.*;
import java.util.*;
public class vk18
{
    public static void main(String[]st)
    {
        Scanner scan=new Scanner(System.in);
        int n,i,x,y,count=0,m;
        n=scan.nextInt();
        x=scan.nextInt();
        y=scan.nextInt();
        for(i=0;i<n;i++)
        {
            m=scan.nextInt();
            if(m <= x) count++;
        }
        if(x>y) System.out.println(n);
        else System.out.println((count+1)/2);

    }
}


import java.io.*;
import java.util.*;
public class vk18
{
    public static void main(String[]st)
    {
        Scanner scan=new Scanner(System.in);
        int n,i,x,y,count=0,m;
        n=scan.nextInt();
        x=scan.nextInt();
        y=scan.nextInt();
        for(i=0;i<n;i++)
        {
            m=scan.nextInt();
            if(m < x) count++;
        }
        if(x>y) System.out.println(n);
        else System.out.println((count+1)/2);

    }
}


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

/**
 *
 * @author ahmed.happa
 */
public class Test {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner reader = new Scanner(System.in);
        int numberOfDoors = reader.nextInt();
        int decreasingQuantity = reader.nextInt();
        int increasingQunatity = reader.nextInt();

        List<Integer> doorsDurability = new ArrayList<>();
        for (int i = 0; i < numberOfDoors; i++) {
            doorsDurability.add(reader.nextInt());
        }

        boolean cantMoveAgain = false;

        if (decreasingQuantity > increasingQunatity) {
            System.out.println(numberOfDoors);
        } else {
            int numberOfOutbutDoors = 0;
            boolean loopAgain = true;
            while (loopAgain) {
                int minimumDurabilityIndex = doorsDurability.indexOf(Collections.min(doorsDurability));
                doorsDurability.set(minimumDurabilityIndex, doorsDurability.get(minimumDurabilityIndex) - decreasingQuantity);
                if (doorsDurability.get(minimumDurabilityIndex) <= 0) {
                    doorsDurability.remove(minimumDurabilityIndex);
                    numberOfOutbutDoors++;
                } else {
                    loopAgain = false;
                }
                int minimumDurabilityIndexForRepair = doorsDurability.indexOf(Collections.min(doorsDurability));
                doorsDurability.set(minimumDurabilityIndexForRepair, doorsDurability.get(minimumDurabilityIndexForRepair) + increasingQunatity);

            }
            System.out.println(numberOfOutbutDoors);
        }

        reader.close();
    }

}


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

/**
 *
 * @author ahmed.happa
 */
public class Test {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner reader = new Scanner(System.in);
        int numberOfDoors = reader.nextInt();
        int decreasingQuantity = reader.nextInt();
        int increasingQunatity = reader.nextInt();

        List<Integer> doorsDurability = new ArrayList<>();
        for (int i = 0; i < numberOfDoors; i++) {
            doorsDurability.add(reader.nextInt());
        }

        boolean cantMoveAgain = false;

        if (decreasingQuantity > increasingQunatity) {
            System.out.println(numberOfDoors);
        } else {
            int numberOfOutbutDoors = 0;
            boolean loopAgain = true;
            while (loopAgain && !doorsDurability.isEmpty()) {
                int minimumDurabilityIndex = doorsDurability.indexOf(Collections.min(doorsDurability));
                doorsDurability.set(minimumDurabilityIndex, doorsDurability.get(minimumDurabilityIndex) - decreasingQuantity);
                if (doorsDurability.get(minimumDurabilityIndex) <= 0) {
                    doorsDurability.remove(minimumDurabilityIndex);
                    numberOfOutbutDoors++;
                } else {
                    loopAgain = false;
                }
                if (!doorsDurability.isEmpty()) {
                    int minimumDurabilityIndexForRepair = doorsDurability.indexOf(Collections.min(doorsDurability));
                    doorsDurability.set(minimumDurabilityIndexForRepair, doorsDurability.get(minimumDurabilityIndexForRepair) + increasingQunatity);
                }
            }
            System.out.println(numberOfOutbutDoors);
        }

        reader.close();
    }

}


import java.util.*;
public class asd
{
    public static void main(String args[])
    {
        Scanner s=new Scanner(System.in);
        int n=s.nextInt();
        int start=s.nextInt();
        int end=s.nextInt();int count=0;
        Integer arr[]=new Integer[n];

        for(int i=0;i<n;i++)
        {      arr[i]=s.nextInt();
               if(arr[i]<=start)
                   count++;
        }
        if(start>end)
            System.out.println(n);
        else
            System.out.println((count+1)/2);
    }
   }


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class q54 {
	public static void main(String[] args) throws IOException {

		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), me=sc.nextInt(), sal= sc.nextInt();
		int x [] = new int [n];
		for(int i=0;i<n;i++)
		  x[i]=sc.nextInt();

		x=shuffle(x);
		Arrays.sort(x);

		if(me>sal) {
			System.out.println(n);
			return;
		}

		int f=1;
		int c=0;
		for(int i=0;i<n;i++) {
			if(x[i]<=me)
				c++;

		}
		if(c%2==0)
		 System.out.println(c/2);
		else
		  System.out.println((int)(c/2)+1);

	}

	static int[] shuffle(int[] a) {
		int n = a.length;
		for (int i = 0; i < n; i++) {
			int r = i + (int) (Math.random() * (n - i));
			int tmp = a[i];
			a[i] = a[r];
			a[r] = tmp;
		}
		return a;
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public Scanner(String file) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(file));
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public long nextlong() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			long res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}
}


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class q54 {
	public static void main(String[] args) throws IOException {

		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), me=sc.nextInt(), sal= sc.nextInt();
		int x [] = new int [n];
		for(int i=0;i<n;i++)
		  x[i]=sc.nextInt();

		x=shuffle(x);
		Arrays.sort(x);

		if(me>sal) {
			System.out.println(n);
			return;
		}

		int f=1;
		int c=0;
		for(int i=0;i<n-1;i=i+2) {
			if(x[i]<=me)
				c++;
			else
				break;
		}
		System.out.println(c);

	}

	static int[] shuffle(int[] a) {
		int n = a.length;
		for (int i = 0; i < n; i++) {
			int r = i + (int) (Math.random() * (n - i));
			int tmp = a[i];
			a[i] = a[r];
			a[r] = tmp;
		}
		return a;
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public Scanner(String file) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(file));
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public long nextlong() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			long res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}
}


import java.util.*;
public class b_prblm {

		static int gcd(int a,int b){
			if(b==0)
				return a;
			return gcd(b,a%b);
		}
	public static void main(String[] args){
		Scanner scn = new Scanner(System.in);
		int n=scn.nextInt();
		int x=scn.nextInt();
		int y=scn.nextInt();
		ArrayList<Integer> al=new ArrayList<>();
		for(int i=0;i<n;i++){
			int v=scn.nextInt();
		if(x<=y){
			if(v<=x){
				al.add(v);
			}
		}else{
			al.add(v);

		}
		}

		if(x<=y){
			System.out.println((int)(Math.ceil(al.size()/2.0)));
		}else{
			System.out.println(al.size());
		}

		}
		}


import java.util.*;
public class b_prblm {

		static int gcd(int a,int b){
			if(b==0)
				return a;
			return gcd(b,a%b);
		}
	public static void main(String[] args){
		Scanner scn = new Scanner(System.in);
		int n=scn.nextInt();
		int x=scn.nextInt();
		int y=scn.nextInt();
		ArrayList<Integer> al=new ArrayList<>();
		for(int i=0;i<n;i++){
			int v=scn.nextInt();
		if(x<=y){
			if(v<=x){
				al.add(v);
			}
		}else{
			al.add(v);

		}
		}

		System.out.println(al);
		if(x<=y){
			System.out.println((int)(Math.ceil(al.size()/2.0)));
		}else{
			System.out.println(al.size());
		}

		}
		}


import java.io.*;
import java.util.*;
public class Doors Breaking and Repairing
{
	public static void main(String args[])
	{
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int x=sc.nextInt();
		int y=sc.nextInt();
		int arr[]=new int[n];
		int count=0;
		for(int i=0;i<n;i++)
		{
			arr[i]=sc.nextInt();
			if(arr[i]<=x)
				++count;
		}
		if(x>y)
			System.out.println(n);
		else
			System.out.println((count+1)/2);

	}
}


import java.io.*;
import java.util.*;
public class Doors_Breaking_and_Repairing
{
	public static void main(String args[])
	{
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int x=sc.nextInt();
		int y=sc.nextInt();
		int arr[]=new int[n];
		int count=0;
		for(int i=0;i<n;i++)
		{
			arr[i]=sc.nextInt();
			if(arr[i]<=x)
				++count;
		}
		if(x>y)
			System.out.println(n);
		else
			System.out.println((count+1)/2);

	}
}


import java.io.;
import java.util.*;
public class Doors Breaking and Repairing
{
	public static void main(String args[])
	{
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int x=sc.nextInt();
		int y=sc.nextInt();
		int arr[]=new int[n];
		int count=0;
		for(int i=0;i<n;i++)
		{
			arr[i]=sc.nextInt();
			if(arr[i]<=x)
				++count;
		}
		if(x>y)
			System.out.println(n);
		else
			System.out.println((count+1)/2);

	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.StringTokenizer;

public class Main {

	static ArrayDeque<Integer> arrayDeque = new ArrayDeque<>();

	static int Answer;
	static int N;
	static int X;
	static int Y;

	public static void main(String[] args) throws IOException {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());

		N = Integer.parseInt(st.nextToken());
		X = Integer.parseInt(st.nextToken());
		Y = Integer.parseInt(st.nextToken());

		st  = new StringTokenizer(br.readLine());
		for(int i = 0; i < N; i++)
			arrayDeque.add(Integer.parseInt(st.nextToken()));

		for(int i = 0; i < N; i++) {

			int var = arrayDeque.remove();

			if(var - X <= 0)
				Answer++;
			else {

				if((var - X) + Y >= var)
					break;
				Answer++;
			}
		}
		System.out.println(Answer);
		br.close();
	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

	static int Answer;
	static int N;
	static int X;
	static int Y;

	public static void main(String[] args) throws IOException {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());

		N = Integer.parseInt(st.nextToken());
		X = Integer.parseInt(st.nextToken());
		Y = Integer.parseInt(st.nextToken());

		st  = new StringTokenizer(br.readLine());

		for(int i = 0; i < N; i++) {

			int var = Integer.parseInt(st.nextToken());

			if(var <= X)
				Answer++;
		}
		if(X > Y)
			System.out.println(N);
		else
			System.out.println((Answer + 1) / 2);
		br.close();
	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.StringTokenizer;

public class Main {

	static ArrayDeque<Integer> arrayDeque = new ArrayDeque<>();

	static int Answer;
	static int N;
	static int X;
	static int Y;

	public static void main(String[] args) throws IOException {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());

		N = Integer.parseInt(st.nextToken());
		X = Integer.parseInt(st.nextToken());
		Y = Integer.parseInt(st.nextToken());

		st  = new StringTokenizer(br.readLine());
		for(int i = 0; i < N; i++)
			arrayDeque.add(Integer.parseInt(st.nextToken()));

		for(int i = 0; i < N; i++) {

			int var = arrayDeque.remove();
			//System.out.println(var);

			if(var <= X)
				Answer++;
			else {

				if(X > Y)
					Answer++;
				else
					break;
			}
		}
		System.out.println(Answer);
		br.close();
	}
}


import java.io.*;
import java.util.*;
public class MainClass
{
	public static void main(String args[])throws IOException
	{
	    try
	    {
    		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    		String t_input[];
            t_input=br.readLine().split(" ");
            int n=Integer.parseInt(t_input[0]);
            int x=Integer.parseInt(t_input[1]);
            int y=Integer.parseInt(t_input[2]);
            String a_input[];
            a_input=br.readLine().split(" ");
            int a[]=new int[n];
            for(int i=0;i<n;i++)
            {
                a[i]=Integer.parseInt(a_input[i]);
            }
            Arrays.sort(a);
            int count=0;
            //System.out.println(x+" "+y);
            for(int i=0;i<n;i++)
            {
                int l=a[i];
                //System.out.print(i+" ");
                a[i]=a[i]-x;
                //System.out.print(a[i]+" ");
                if(a[i]<=0)
                {
                    a[i]=0;
                    if(i+1<n)
                    a[i+1]=a[i+1]+y;
                }
                else
                a[i]=a[i]+y;
                //System.out.print(a[i]+" ");
                if(a[i]>=l)
                continue;
                count++;
                //System.out.println();
            }
           System.out.println(count);
	    }
		catch(NumberFormatException x){}
	}
}
/*
__________TEST INPUT:
test=Integer.parseInt(br.readLine());

__________n INPUT:
n=Integer.parseInt(br.readLine());

__________ARRAY INPUT:
String a_input[];
a_input=br.readLine().split(" ");
a[]=new int[n];
for(int i=0;i<n;i++)
{
    a[i]=Integer.parseInt(a_input[i]);
}

__________INPUT FOR TWO SPACE SEPARATED INTEGERS:
String t_input[];
t_input=br.readLine().split(" ");
n=Integer.parseInt(t_input[0]);
k=Integer.parseInt(t_input[1]);

__________FAST MULTIPLICATION(EXPONENTIAL SQUARING):
static long fpow(int base,int power)
    {
        final int M=1000000007;
        if(power==1)
        return base;
        else
        {
            if(power%2==0)
            {
                long x=(long)Math.pow(fpow(base,power/2),2);
                //MODULO M if required:
                if(x>= M)
                return x%M;
                else
                return x;
            }
            else
            {
                long x=(long)(base*Math.pow(fpow(base,(power-1)/2),2));
                //MODULO M if required:
                if(x>= M)
                return x%M;
                else
                return x;
            }
        }
    }

__________FAST MULTIPLICATION 2(EXPONENTIAL SQUARING):
static long fpow(int base,int power)
	{
        long x=1;
        //final int M=1000000007;
        //MODULO M if required
        while(power>0)
        {
           if(power%2==1)
           x=(x*base);//%M;
           base=(base*base);//%M;
           power/=2;
        }
        return x;
    }

*/


import java.io.*;
import java.util.*;
public class MainClass
{
	public static void main(String args[])throws IOException
	{
	    try
	    {
    		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    		String t_input[];
            t_input=br.readLine().split(" ");
            int n=Integer.parseInt(t_input[0]);
            int x=Integer.parseInt(t_input[1]);
            int y=Integer.parseInt(t_input[2]);
            String a_input[];
            a_input=br.readLine().split(" ");
            int a[]=new int[n];
            for(int i=0;i<n;i++)
            {
                a[i]=Integer.parseInt(a_input[i]);
            }
            Arrays.sort(a);
            int count=0;
            //System.out.println(x+" "+y);
            for(int i=0;i<n;i++)
            {
                int l=a[i];
                //System.out.print(i+" ");
                a[i]=a[i]-x;
                //System.out.print(a[i]+" ");
                if(a[i]<=0)
                {
                    a[i]=0;
                    if(a[i+1]<n)
                    a[i+1]=a[i+1]+y;
                }
                else
                a[i]=a[i]+y;
                //System.out.print(a[i]+" ");
                if(a[i]>=l)
                continue;
                count++;
                //System.out.println();
            }
           System.out.println(count);
	    }
		catch(NumberFormatException x){}
	}
}
/*
__________TEST INPUT:
test=Integer.parseInt(br.readLine());

__________n INPUT:
n=Integer.parseInt(br.readLine());

__________ARRAY INPUT:
String a_input[];
a_input=br.readLine().split(" ");
a[]=new int[n];
for(int i=0;i<n;i++)
{
    a[i]=Integer.parseInt(a_input[i]);
}

__________INPUT FOR TWO SPACE SEPARATED INTEGERS:
String t_input[];
t_input=br.readLine().split(" ");
n=Integer.parseInt(t_input[0]);
k=Integer.parseInt(t_input[1]);

__________FAST MULTIPLICATION(EXPONENTIAL SQUARING):
static long fpow(int base,int power)
    {
        final int M=1000000007;
        if(power==1)
        return base;
        else
        {
            if(power%2==0)
            {
                long x=(long)Math.pow(fpow(base,power/2),2);
                //MODULO M if required:
                if(x>= M)
                return x%M;
                else
                return x;
            }
            else
            {
                long x=(long)(base*Math.pow(fpow(base,(power-1)/2),2));
                //MODULO M if required:
                if(x>= M)
                return x%M;
                else
                return x;
            }
        }
    }

__________FAST MULTIPLICATION 2(EXPONENTIAL SQUARING):
static long fpow(int base,int power)
	{
        long x=1;
        //final int M=1000000007;
        //MODULO M if required
        while(power>0)
        {
           if(power%2==1)
           x=(x*base);//%M;
           base=(base*base);//%M;
           power/=2;
        }
        return x;
    }

*/


import java.io.*;
import java.util.*;
public class MainClass
{
	public static void main(String args[])throws IOException
	{
	    try
	    {
    		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    		String t_input[];
            t_input=br.readLine().split(" ");
            int n=Integer.parseInt(t_input[0]);
            int x=Integer.parseInt(t_input[1]);
            int y=Integer.parseInt(t_input[2]);
            String a_input[];
            a_input=br.readLine().split(" ");
            int a[]=new int[n];
            for(int i=0;i<n;i++)
            {
                a[i]=Integer.parseInt(a_input[i]);
            }
            Arrays.sort(a);
            int count=0;
            //System.out.println(x+" "+y);
            for(int i=0;i<n;i++)
            {
                int l=a[i];
                //System.out.print(i+" ");
                a[i]=a[i]-x;
                //System.out.print(a[i]+" ");
                if(a[i]<=0)
                {
                    a[i]=0;
                    a[i+1]=a[i+1]+y;
                }
                else
                a[i]=a[i]+y;
                //System.out.print(a[i]+" ");
                if(a[i]>=l)
                continue;
                count++;
                //System.out.println();
            }
           System.out.println(count);
	    }
		catch(NumberFormatException x){}
	}
}
/*
__________TEST INPUT:
test=Integer.parseInt(br.readLine());

__________n INPUT:
n=Integer.parseInt(br.readLine());

__________ARRAY INPUT:
String a_input[];
a_input=br.readLine().split(" ");
a[]=new int[n];
for(int i=0;i<n;i++)
{
    a[i]=Integer.parseInt(a_input[i]);
}

__________INPUT FOR TWO SPACE SEPARATED INTEGERS:
String t_input[];
t_input=br.readLine().split(" ");
n=Integer.parseInt(t_input[0]);
k=Integer.parseInt(t_input[1]);

__________FAST MULTIPLICATION(EXPONENTIAL SQUARING):
static long fpow(int base,int power)
    {
        final int M=1000000007;
        if(power==1)
        return base;
        else
        {
            if(power%2==0)
            {
                long x=(long)Math.pow(fpow(base,power/2),2);
                //MODULO M if required:
                if(x>= M)
                return x%M;
                else
                return x;
            }
            else
            {
                long x=(long)(base*Math.pow(fpow(base,(power-1)/2),2));
                //MODULO M if required:
                if(x>= M)
                return x%M;
                else
                return x;
            }
        }
    }

__________FAST MULTIPLICATION 2(EXPONENTIAL SQUARING):
static long fpow(int base,int power)
	{
        long x=1;
        //final int M=1000000007;
        //MODULO M if required
        while(power>0)
        {
           if(power%2==1)
           x=(x*base);//%M;
           base=(base*base);//%M;
           power/=2;
        }
        return x;
    }

*/


import java.io.*;
import java.util.*;

public class Main{
    public static void main(String[] args) {
        FastReader fs=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int t=1;
        //t=fs.nextInt();
        for(int i=1;i<=t;i++) {
        	Main m=new Main();
            m.solve(i,out,fs);
        }
        out.close();
    }

    public void solve(int test,PrintWriter out,FastReader fs){
        int n=fs.nextInt();
        int x=fs.nextInt(),y=fs.nextInt();
        if(x>y){
            out.println(n);
            return;
        }
        int a[]=fs.nextIntArray(n);
        int count=0;
        for(int i=0;i<n;i++)
            if(a[i]<x)count++;
        out.println( (count+1)/2 );
    }
}
class shedule{
    int a,b;
    shedule(int a,int b){
        this.a=a;
        this.b=b;
    }
}
class FastReader{
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
        while(!st.hasMoreTokens()){
            try {
                st=new StringTokenizer(br.readLine());
            } catch (IOException e) {
				e.printStackTrace();
			}
        }
        return st.nextToken();
    }
    int nextInt(){
        return Integer.parseInt(next());
    }
    long nextLong(){
        return Long.parseLong(next());
    }
    int[] nextIntArray(int n){
        int a[]=new int[n];
        for(int i=0;i<n;i++)a[i]=nextInt();
        return a;
    }
    long[] nextLongArray(int n){
        long a[]=new long[n];
        for(int i=0;i<n;i++)a[i]=nextInt();
        return a;
    }
    char[] nextCharArray(){
        char a[]=next().toCharArray();
        return a;
    }
}


import java.io.*;
import java.util.*;

public class Main{
    public static void main(String[] args) {
        FastReader fs=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int t=1;
        //t=fs.nextInt();
        for(int i=1;i<=t;i++) {
        	Main m=new Main();
            m.solve(i,out,fs);
        }
        out.close();
    }

    public void solve(int test,PrintWriter out,FastReader fs){
        int n=fs.nextInt();
        int x=fs.nextInt(),y=fs.nextInt();
        if(x>y){
            out.println(n);
            return;
        }
        int a[]=fs.nextIntArray(n);
        int count=0;
        for(int i=0;i<n;i++)
            if(a[i]<=x)count++;
        out.println( (count+1)/2 );
    }
}
class shedule{
    int a,b;
    shedule(int a,int b){
        this.a=a;
        this.b=b;
    }
}
class FastReader{
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
        while(!st.hasMoreTokens()){
            try {
                st=new StringTokenizer(br.readLine());
            } catch (IOException e) {
				e.printStackTrace();
			}
        }
        return st.nextToken();
    }
    int nextInt(){
        return Integer.parseInt(next());
    }
    long nextLong(){
        return Long.parseLong(next());
    }
    int[] nextIntArray(int n){
        int a[]=new int[n];
        for(int i=0;i<n;i++)a[i]=nextInt();
        return a;
    }
    long[] nextLongArray(int n){
        long a[]=new long[n];
        for(int i=0;i<n;i++)a[i]=nextInt();
        return a;
    }
    char[] nextCharArray(){
        char a[]=next().toCharArray();
        return a;
    }
}


/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{

		static int upper_bound ( int arr [ ] , int start , int end , int x )
	{
		if ( start > end ) return end  ;
		int mid = ( start + end ) / 2 ;
		if ( arr [ mid ] <= x )
			return upper_bound ( arr , mid + 1  , end  , x ) ;
		else
			return upper_bound ( arr , start  , mid - 1  , x ) ;
	}
	public static void main (String[] args) throws java.lang.Exception
	{

		int n , x , y ;
		Scanner in  = new Scanner ( System.in ) ;
		n = in.nextInt() ;
		x = in.nextInt() ;
		y = in.nextInt() ;
		int arr [ ] = new int [ n ] ;
		for ( int i = 0 ; i < n ; i ++ )
			arr [ i ] = in.nextInt() ;
		Arrays.sort ( arr ) ;
		if ( x <= y )
		{
			int i = upper_bound ( arr , 0  , n - 1  , x ) ;
			System.out.println ( ( int ) Math.ceil ( ( float ) i / 2  ) )  ;
		}
		else
		{
			System.out.println ( n ) ;
		}
		// your code goes here
	}
}


/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{

	static int lower_bound ( int arr [ ] , int start , int end , int x )
	{
		if ( start > end ) return start ;
		int mid = ( start + end ) / 2 ;
		if ( arr [ mid ] >= x )
			return lower_bound ( arr , start , mid - 1 , x ) ;
		else
			return lower_bound ( arr , mid + 1 , end , x ) ;
	}
	public static void main (String[] args) throws java.lang.Exception
	{

		int n , x , y ;
		Scanner in  = new Scanner ( System.in ) ;
		n = in.nextInt() ;
		x = in.nextInt() ;
		y = in.nextInt() ;
		int arr [ ] = new int [ n ] ;
		for ( int i = 0 ; i < n ; i ++ )
			arr [ i ] = in.nextInt() ;
		Arrays.sort ( arr ) ;
		if ( x <= y )
		{
			int i = lower_bound ( arr , 0  , n - 1  , x ) ;
			System.out.println ( ( int ) Math.ceil ( ( float ) i / 2  ) )  ;
		}
		else
		{
			System.out.println ( n ) ;
		}
		// your code goes here
	}
}


/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{

		static int upper_bound ( int arr [ ] , int start , int end , int x )
	{
		if ( start > end ) return start ;
		int mid = ( start + end ) / 2 ;
		if ( arr [ mid ] <= x )
			return upper_bound ( arr , mid + 1  , end  , x ) ;
		else
			return upper_bound ( arr , start  , mid - 1  , x ) ;
	}
	public static void main (String[] args) throws java.lang.Exception
	{

		int n , x , y ;
		Scanner in  = new Scanner ( System.in ) ;
		n = in.nextInt() ;
		x = in.nextInt() ;
		y = in.nextInt() ;
		int arr [ ] = new int [ n ] ;
		for ( int i = 0 ; i < n ; i ++ )
			arr [ i ] = in.nextInt() ;
		Arrays.sort ( arr ) ;
		if ( x <= y )
		{
			int i = upper_bound ( arr , 0  , n - 1  , x ) ;
			//System.out.println ( i ) ;
			System.out.println ( ( int ) Math.ceil ( ( float ) i / 2  ) )  ;
		}
		else
		{
			System.out.println ( n ) ;
		}
		// your code goes here
	}
}


import java.util.*;

public class Test1 {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), x = in.nextInt(), y = in.nextInt(), cnt = 0;
        for(int i = 0; i<n; i++) if(in.nextInt()<=x) cnt++;
        if(x>y) System.out.println(n);
        else System.out.println((cnt+1)/2);
    }
}


import java.util.*;

public class Test1 {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), x = in.nextInt(), y = in.nextInt(), cnt = 0;
        for(int i = 0; i<n; i++) if(in.nextInt()<=x) cnt++;
        if(x>y) System.out.println(0);
        else System.out.println(cnt-1);
    }
}


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Solution {

	public static void main(String[] args) throws Exception {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		int n = Integer.parseInt(st.nextToken());
		int x = Integer.parseInt(st.nextToken());
		int y = Integer.parseInt(st.nextToken());

		if (x > y) {
			System.out.println(n);
			return;
		}
		st = new StringTokenizer(br.readLine());
		int count = 0;
		for (int i = 0; i < n; i++) {
			int p = Integer.parseInt(st.nextToken());
			if (p < x)
				count++;
		}

		System.out.println((count + 1) / 2);

	}
}


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Solution {

	public static void main(String[] args) throws Exception {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		int n = Integer.parseInt(st.nextToken());
		int x = Integer.parseInt(st.nextToken());
		int y = Integer.parseInt(st.nextToken());

		if (x > y) {
			System.out.println(n);
			return;
		}
		st = new StringTokenizer(br.readLine());
		int count = 0;
		for (int i = 0; i < n; i++) {
			int p = Integer.parseInt(st.nextToken());
			if (p <= x)
				count++;
		}

		System.out.println((count + 1) / 2);

	}
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in Actual solution is at the top
 *
 * @author @Ziklon
 */
public class Main {
  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    InputReader in = new InputReader(inputStream);
    OutputWriter out = new OutputWriter(outputStream);
    CDoorsBreakingAndRepairing solver = new CDoorsBreakingAndRepairing();
    solver.solve(1, in, out);
    out.close();
  }

  static class CDoorsBreakingAndRepairing {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
      int n = in.readInt(), x = in.readInt(), y = in.readInt();

      if (x > y) out.printLine(n);
      else {
        int ans = 0;
        for (int i = 0; i < n; ++i) {
          int e = in.readInt();
          if (e < x) ans++;
        }
        out.printLine((ans + 1) >> 1);
      }
    }
  }

  static class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
      writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
      this.writer = new PrintWriter(writer);
    }

    public void close() {
      writer.close();
    }

    public void printLine(int i) {
      writer.println(i);
    }
  }

  static class InputReader {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private InputReader.SpaceCharFilter filter;

    public InputReader(InputStream stream) {
      this.stream = stream;
    }

    public int read() {
      if (numChars == -1) {
        throw new InputMismatchException();
      }
      if (curChar >= numChars) {
        curChar = 0;
        try {
          numChars = stream.read(buf);
        } catch (IOException e) {
          throw new InputMismatchException();
        }
        if (numChars <= 0) {
          return -1;
        }
      }
      return buf[curChar++];
    }

    public int readInt() {
      int c = read();
      while (isSpaceChar(c)) {
        c = read();
      }
      int sgn = 1;
      if (c == '-') {
        sgn = -1;
        c = read();
      }
      int res = 0;
      do {
        if (c < '0' || c > '9') {
          throw new InputMismatchException();
        }
        res *= 10;
        res += c - '0';
        c = read();
      } while (!isSpaceChar(c));
      return res * sgn;
    }

    public boolean isSpaceChar(int c) {
      if (filter != null) {
        return filter.isSpaceChar(c);
      }
      return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
      return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter {
      public boolean isSpaceChar(int ch);
    }
  }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in Actual solution is at the top
 *
 * @author @Ziklon
 */
public class Main {
  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    InputReader in = new InputReader(inputStream);
    OutputWriter out = new OutputWriter(outputStream);
    CDoorsBreakingAndRepairing solver = new CDoorsBreakingAndRepairing();
    solver.solve(1, in, out);
    out.close();
  }

  static class CDoorsBreakingAndRepairing {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
      int n = in.readInt(), x = in.readInt(), y = in.readInt();

      if (x > y) out.printLine(n);
      else {
        int ans = 0;
        for (int i = 0; i < n; ++i) {
          int e = in.readInt();
          if (e <= x) ans++;
        }
        out.printLine((ans + 1) >> 1);
      }
    }
  }

  static class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
      writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
      this.writer = new PrintWriter(writer);
    }

    public void close() {
      writer.close();
    }

    public void printLine(int i) {
      writer.println(i);
    }
  }

  static class InputReader {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private InputReader.SpaceCharFilter filter;

    public InputReader(InputStream stream) {
      this.stream = stream;
    }

    public int read() {
      if (numChars == -1) {
        throw new InputMismatchException();
      }
      if (curChar >= numChars) {
        curChar = 0;
        try {
          numChars = stream.read(buf);
        } catch (IOException e) {
          throw new InputMismatchException();
        }
        if (numChars <= 0) {
          return -1;
        }
      }
      return buf[curChar++];
    }

    public int readInt() {
      int c = read();
      while (isSpaceChar(c)) {
        c = read();
      }
      int sgn = 1;
      if (c == '-') {
        sgn = -1;
        c = read();
      }
      int res = 0;
      do {
        if (c < '0' || c > '9') {
          throw new InputMismatchException();
        }
        res *= 10;
        res += c - '0';
        c = read();
      } while (!isSpaceChar(c));
      return res * sgn;
    }

    public boolean isSpaceChar(int c) {
      if (filter != null) {
        return filter.isSpaceChar(c);
      }
      return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
      return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter {
      public boolean isSpaceChar(int ch);
    }
  }
}


import java.util.Scanner;

public class Round530_C {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int x = sc.nextInt();
        int y = sc.nextInt();
        int[] arr = new int[n];
        int count_less = 0;
        int count_same = 0;
        if(x > y) {
            System.out.println(n);
            return;
        }
        for(int i = 0;i<n;i++) {
            arr[i] = sc.nextInt();
            int cur = arr[i];
            if(cur < x) {
                count_less++;
            }
            if(cur == x) {
                count_same++;
            }
        }

            count_less = count_same + count_less;

        if(count_less%2 == 0) {
            System.out.println(count_less/2);
        } else {
            int out = count_less/2 + 1;
            System.out.println(out);
        }

    }
}


import java.util.Scanner;

public class Round530_C {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int x = sc.nextInt();
        int y = sc.nextInt();
        //int[] arr = new int[n];
        int count_less = 0;
        int count_same = 0;
        if(x > y) {
            System.out.println(n);
            return;
        }
        for(int i = 0;i<n;i++) {
            //arr[i] = sc.nextInt();
            int cur = sc.nextInt();
            if(cur < x) {
                count_less++;
            }
            if(cur == x) {
                count_same++;
            }
        }

        if(x == y) {
            count_less = count_same + count_less;
        }

        if(count_less%2 == 0) {
            System.out.println(count_less/2);
        } else {
            int out = count_less/2 + 1;
            System.out.println(out);
        }

    }
}


import java.util.*;
import java.lang.*;
public class code{
public static void main(String args[]){
	Scanner sc=new Scanner(System.in);
	int n=sc.nextInt();
	int x=sc.nextInt();
	int y=sc.nextInt();
	int t=0;
	int arr[]=new int[n];
	for(int i=0;i<n;i++){
		arr[i]=sc.nextInt();

	}
	if(x>y)System.out.println(n);
	else{
		for(int i=0;i<n;i++){
		if(arr[i]<=x){
			t++;
		}
		}
		if(t%2==0)System.out.println(t/2);
		else System.out.println((t/2)+1);
	}
}
}


import java.util.*;
import java.lang.*;
public class code{
public static void main(String args[]){
	Scanner sc=new Scanner(System.in);
	int n=sc.nextInt();
	int x=sc.nextInt();
	int y=sc.nextInt();
	int t=0;
	int arr[]=new int[n];
	for(int i=0;i<n;i++){
		arr[i]=sc.nextInt();

	}
	if(x>y)System.out.println(n);
	else{
		for(int i=0;i<n;i++){
		if(arr[i]<=y){
			t++;
		}
		}
		if(t%2==0)System.out.println(t/2);
		else System.out.println((t/2)+1);
	}
}
}


/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int x=sc.nextInt();
		int y=sc.nextInt();
		int[] a=new int[n];
		for(int i=0;i<n;i++)
		a[i]=sc.nextInt();

		if(x>y)
		{
			System.out.println(n);
			System.exit(0);
		}
		else
		{
			int c=0;
			for(int i=0;i<n;i++)
			{
				if(a[i]<=x)
				c++;
			}

			System.out.println((int)Math.ceil((double)c/2));
		}

	}
}


/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int x=sc.nextInt();
		int y=sc.nextInt();
		int[] a=new int[n];
		for(int i=0;i<n;i++)
		a[i]=sc.nextInt();

		if(x>y)
		{
			System.out.println(n);
			System.exit(0);
		}
		else
		{
			int c=0;
			for(int i=0;i<n;i++)
			{
				if(a[i]<=x)
				c++;
			}

			System.out.println((int)Math.ceil(c/2));
		}

	}
}


/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int x=sc.nextInt();
		int y=sc.nextInt();
		int[] a=new int[n];
		for(int i=0;i<n;i++)
		a[i]=sc.nextInt();

		if(x>y)
		{
			System.out.println(n);
			System.exit(0);
		}
		else
		{
			int c=0;
			for(int i=0;i<n;i++)
			{
				if(a[i]<=x)
				c++;
			}

			System.out.println((int)Math.floor(c/2));
		}

	}
}


import java.io.*;
import java.util.*;
import java.lang.Math;

public class Main {

    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner() {
            try {
                br = new BufferedReader(new InputStreamReader(System.in));
                st = new StringTokenizer(br.readLine());
            } catch (Exception e){e.printStackTrace();}
        }

        public String next() {
            if (st.hasMoreTokens()) return st.nextToken();
            try {st = new StringTokenizer(br.readLine());}
            catch (Exception e) {e.printStackTrace();}
            return st.nextToken();
        }

        public int nextInt() {return Integer.parseInt(next());}

        public long nextLong() {return Long.parseLong(next());}

        public double nextDouble() {return Double.parseDouble(next());}

        public String nextLine() {
            String line = "";
            if(st.hasMoreTokens()) line = st.nextToken();
            else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
            while(st.hasMoreTokens()) line += " "+st.nextToken();
            return line;
        }
    }

    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        PrintWriter pw = new PrintWriter(System.out);
        final int MOD = 1000000007;

        int n = sc.nextInt(), x = sc.nextInt(), y = sc.nextInt();
        if(x > y) {
            pw.println(n);
        }
        else {
            int cnt = 0;
            for(int i=0;i<n;i++) {
                if(sc.nextInt() <= x) cnt++;
            }
            pw.println(Math.max(0, cnt - 1));
        }

        pw.close();
    }
}


import java.io.*;
import java.util.*;
import java.lang.Math;

public class Main {

    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner() {
            try {
                br = new BufferedReader(new InputStreamReader(System.in));
                st = new StringTokenizer(br.readLine());
            } catch (Exception e){e.printStackTrace();}
        }

        public String next() {
            if (st.hasMoreTokens()) return st.nextToken();
            try {st = new StringTokenizer(br.readLine());}
            catch (Exception e) {e.printStackTrace();}
            return st.nextToken();
        }

        public int nextInt() {return Integer.parseInt(next());}

        public long nextLong() {return Long.parseLong(next());}

        public double nextDouble() {return Double.parseDouble(next());}

        public String nextLine() {
            String line = "";
            if(st.hasMoreTokens()) line = st.nextToken();
            else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
            while(st.hasMoreTokens()) line += " "+st.nextToken();
            return line;
        }
    }

    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        PrintWriter pw = new PrintWriter(System.out);
        final int MOD = 1000000007;

        int n = sc.nextInt(), x = sc.nextInt(), y = sc.nextInt();
        if(x > y) {
            pw.println(n);
        }
        else {
            int cnt = 0;
            for(int i=0;i<n;i++) {
                if(sc.nextInt() <= x) cnt++;
            }
            pw.println((int)Math.ceil(cnt / 2.0));
        }

        pw.close();
    }
}

//ceil(a/b) = (a+b-1)/b


import java.io.*;
import java.util.*;
import java.lang.Math;

public class Main {

    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner() {
            try {
                br = new BufferedReader(new InputStreamReader(System.in));
                st = new StringTokenizer(br.readLine());
            } catch (Exception e){e.printStackTrace();}
        }

        public String next() {
            if (st.hasMoreTokens()) return st.nextToken();
            try {st = new StringTokenizer(br.readLine());}
            catch (Exception e) {e.printStackTrace();}
            return st.nextToken();
        }

        public int nextInt() {return Integer.parseInt(next());}

        public long nextLong() {return Long.parseLong(next());}

        public double nextDouble() {return Double.parseDouble(next());}

        public String nextLine() {
            String line = "";
            if(st.hasMoreTokens()) line = st.nextToken();
            else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
            while(st.hasMoreTokens()) line += " "+st.nextToken();
            return line;
        }
    }

    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        PrintWriter pw = new PrintWriter(System.out);
        final int MOD = 1000000007;

        int n = sc.nextInt(), x = sc.nextInt(), y = sc.nextInt();
        if(x > y) {
            pw.println(n);
        }
        else {
            int cnt = 0;
            for(int i=0;i<n;i++) {
                if(sc.nextInt() <= x) cnt++;
            }
            pw.println((int)Math.ceil(cnt / 2));
        }

        pw.close();
    }
}

//ceil(a/b) = (a+b-1)/b


import java.io.*;
import java.util.*;

public class C {

	public static void main(String[] args) throws IOException {

		Scanner scn = new Scanner(System.in);
		int n = scn.nextInt();
		int x = scn.nextInt(), y = scn.nextInt();
		Integer a[] = new Integer[n];
		for (int i = 0; i < n; i++)
			a[i] = scn.nextInt();
		if (y < x) {
			System.out.println(n);
			return;
		}
		Arrays.sort(a);
		if (a[0] > x) {
			System.out.println(0);
			return;
		}
		int idx = Arrays.binarySearch(a, x);
		idx = idx < 0 ? -(idx + 1) : idx;
		while (idx > 0 && a[idx] == a[--idx])
			;
		System.out.println(idx / 2 + 1);
	}

	static class Scanner {

		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
	}
}
package CodeForces;

import java.io.*;
import java.util.*;

public class C {

	public static void main(String[] args) throws IOException {

		Scanner scn = new Scanner(System.in);
		int n = scn.nextInt();
		int x = scn.nextInt(), y = scn.nextInt();
		Integer a[] = new Integer[n];
		for (int i = 0; i < n; i++)
			a[i] = scn.nextInt();
		if (y < x) {
			System.out.println(n);
			return;
		}
		Arrays.sort(a);
		if (a[0] > x) {
			System.out.println(0);
			return;
		}
		int idx = Arrays.binarySearch(a, x);
		idx = idx < 0 ? -(idx + 1) : idx;
		while (idx > 0 && a[idx] == a[--idx])
			;
		System.out.println(idx / 2 + 1);
	}

	static class Scanner {

		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
	}
}


import java.io.*;
import java.util.*;

public class C {

	public static void main(String[] args) throws IOException {

		Scanner scn = new Scanner(System.in);
		int n = scn.nextInt();
		int x = scn.nextInt(), y = scn.nextInt();
		ArrayList<Integer> al = new ArrayList<>();
		for (int i = 0; i < n; i++) {
			int v = scn.nextInt();
			if (y < x)
				al.add(v);
			else {
				if (v <= x)
					al.add(v);
			}
		}
		if (y < x)
			System.out.println(al.size());
		else
			System.out.println((int) (Math.ceil(al.size() * 1.0 / 2)));
	}

	static class Scanner {

		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
	}
}


import java.io.*;
import java.util.*;

public class C {

	public static void main(String[] args) throws IOException {

		Scanner scn = new Scanner(System.in);
		int n = scn.nextInt();
		int x = scn.nextInt(), y = scn.nextInt();
		Integer a[] = new Integer[n];
		for (int i = 0; i < n; i++)
			a[i] = scn.nextInt();
		if (y < x) {
			System.out.println(n);
			return;
		}
		Arrays.sort(a);
		if (a[0] > x) {
			System.out.println(0);
			return;
		}
		int idx = Arrays.binarySearch(a, x + 1);
		if (idx < 0)
			idx = -(idx + 1) - 1;
		else
			while (idx > 0 && a[idx] == a[--idx])
				;
		System.out.println(idx / 2 + 1);
	}

	static class Scanner {

		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
	}
}


import java.io.*;
import java.util.*;

public class C {

	public static void main(String[] args) throws IOException {

		Scanner scn = new Scanner(System.in);
		int n = scn.nextInt();
		int x = scn.nextInt(), y = scn.nextInt();
		int a[] = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = scn.nextInt();
		if (y < x) {
			System.out.println(n);
			return;
		}
		Arrays.sort(a);
		if (a[0] > x) {
			System.out.println(0);
			return;
		}
		int idx = Arrays.binarySearch(a, x + 1);
		if (idx < 0)
			idx = -(idx + 1) - 1;
		else
			while (idx > 0 && a[idx] == a[idx - 1])
				idx--;
		System.out.println(idx / 2 + 1);
	}

	static class Scanner {

		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
	}
}


import java.io.*;
import java.util.*;

public class C {

	public static void main(String[] args) throws IOException {

		Scanner scn = new Scanner(System.in);
		int n = scn.nextInt();
		int x = scn.nextInt(), y = scn.nextInt();
		ArrayList<Integer> al = new ArrayList<>();
		for (int i = 0; i < n; i++) {
			int v = scn.nextInt();
			if (y < x)
				al.add(v);
			else {
				if (v <= x)
					al.add(v);
			}
		}
		if (y < x)
			System.out.println(al.size());
		else
			System.out.println((int)Math.ceil(al.size() / 2));
	}

	static class Scanner {

		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
	}
}


import java.io.*;
import java.util.*;

public class C {

	public static void main(String[] args) throws IOException {

		Scanner scn = new Scanner(System.in);
		int n = scn.nextInt();
		int x = scn.nextInt(), y = scn.nextInt();
		Integer a[] = new Integer[n];
		for (int i = 0; i < n; i++)
			a[i] = scn.nextInt();
		if (y < x) {
			System.out.println(n);
			return;
		}
		Arrays.sort(a);
		int idx = Arrays.binarySearch(a, x);
		idx = idx < 0 ? -(idx + 1) : idx;
		while (idx > 0 && a[idx] == a[--idx])
			;
		System.out.println(idx / 2 + 1);
	}

	static class Scanner {

		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
	}
}


import java.io.*;
import java.util.*;

public class C {

	public static void main(String[] args) throws IOException {

		Scanner scn = new Scanner(System.in);
		int n = scn.nextInt();
		int x = scn.nextInt(), y = scn.nextInt();
		Integer a[] = new Integer[n];
		for (int i = 0; i < n; i++)
			a[i] = scn.nextInt();
		if (y < x) {
			System.out.println(n);
			return;
		}
		Arrays.sort(a);
		if (a[0] > x) {
			System.out.println(0);
			return;
		}
		int idx = Arrays.binarySearch(a, x);
		if (idx < 0)
			idx = -(idx + 1) - 1;
		else
			while (idx > 0 && a[idx] == a[--idx])
				;
		System.out.println(idx / 2 + 1);
	}

	static class Scanner {

		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
	}
}


import java.io.*;
import java.util.*;

public class C {

	public static void main(String[] args) throws IOException {

		Scanner scn = new Scanner(System.in);
		int n = scn.nextInt();
		int x = scn.nextInt(), y = scn.nextInt();
		Integer a[] = new Integer[n];
		for (int i = 0; i < n; i++)
			a[i] = scn.nextInt();
		if (y < x) {
			System.out.println(n);
			return;
		}
		Arrays.sort(a);
		if (a[0] > x) {
			System.out.println(0);
			return;
		}
		int idx = Arrays.binarySearch(a, x);
		idx = idx < 0 ? -(idx + 1) : idx;
		while (idx > 0 && a[idx] == a[--idx])
			;
		System.out.println(idx / 2 + 1);
	}

	static class Scanner {

		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
	}
}


import java.io.*;
import java.util.*;

public class C {

	public static void main(String[] args) throws IOException {

		Scanner scn = new Scanner(System.in);
		int n = scn.nextInt();
		int x = scn.nextInt(), y = scn.nextInt();
		int a[] = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = scn.nextInt();
		if (y < x) {
			System.out.println(n);
			return;
		}
		Arrays.sort(a);
		if (a[0] > x) {
			System.out.println(0);
			return;
		}
		int idx = Arrays.binarySearch(a, x + 1);
		if (idx < 0)
			idx = -(idx + 1) - 1;
		else
			while (idx > 0 && a[idx] == a[--idx])
				;
		System.out.println(idx / 2 + 1);
	}

	static class Scanner {

		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
	}
}


import static java.lang.Double.parseDouble;
import static java.lang.Integer.MAX_VALUE;
import static java.lang.Integer.max;
import static java.lang.Long.max;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Math.abs;
import static java.lang.Math.min;
import static java.lang.Math.toRadians;
import static java.lang.System.exit;
import static java.lang.System.gc;

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class A {

    static BufferedReader in;
    static PrintWriter out;
    static StringTokenizer tok;

    void solve() throws Exception {
        int n = nextInt(), x = nextInt(), y = nextInt(), d = 0;
        int a[] = na(n);
        if(x > y) {
            out.println(n);
        } else {
            for(int aa:a) if(aa <= x) d++;
            out.println((d+1) / 2);
        }
    }

    public int lower_bound(long[] a, long v) {
        int low = -1, high = a.length;
        while (high - low > 1) {
            int h = high + low >>> 1;
            if (a[h] >= v) {
                high = h;
            } else {
                low = h;
            }
        }
        return high;
    }

    private int gcd(int a, int b) {
        while (b > 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

    private int lcm(int a, int b) {
        return a * (b / gcd(a, b));
    }

    private int[] na(int n) throws IOException {
        int[] a = new int[n];
        for (int i = 0; i < n; i++) a[i] = nextInt();
        return a;
    }

    private long[] nal(int n) throws IOException {
        long[] a = new long[n];
        for (int i = 0; i < n; i++) a[i] = nextLong();
        return a;
    }

    int nextInt() throws IOException {
        return parseInt(next());
    }

    long nextLong() throws IOException {
        return parseLong(next());
    }

    double nextDouble() throws IOException {
        return parseDouble(next());
    }

    String next() throws IOException {
        while (tok == null || !tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    public static void main(String[] args) throws Exception {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(new OutputStreamWriter(System.out));
            //long lStartTime = System.currentTimeMillis();
            new A().solve();
            //long lEndTime = System.currentTimeMillis();
            //out.println("Elapsed time in seconds: " + (double)(lEndTime - lStartTime) / 1000.0);
            in.close();
            out.close();
        } catch (Throwable e) {
            e.printStackTrace();
            exit(1);
        }
    }
}


import static java.lang.Double.parseDouble;
import static java.lang.Integer.MAX_VALUE;
import static java.lang.Integer.max;
import static java.lang.Long.max;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Math.abs;
import static java.lang.Math.min;
import static java.lang.Math.toRadians;
import static java.lang.System.exit;
import static java.lang.System.gc;

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class A {

    static BufferedReader in;
    static PrintWriter out;
    static StringTokenizer tok;

    void solve() throws Exception {
        int n = nextInt(), x = nextInt(), y = nextInt(), d = 1;
        int a[] = na(n);
        for(int aa:a) if(aa <= x) d++;
        out.println(x > y ? n : d / 2);
    }

    public int lower_bound(long[] a, long v) {
        int low = -1, high = a.length;
        while (high - low > 1) {
            int h = high + low >>> 1;
            if (a[h] >= v) {
                high = h;
            } else {
                low = h;
            }
        }
        return high;
    }

    private int gcd(int a, int b) {
        while (b > 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

    private int lcm(int a, int b) {
        return a * (b / gcd(a, b));
    }

    private int[] na(int n) throws IOException {
        int[] a = new int[n];
        for (int i = 0; i < n; i++) a[i] = nextInt();
        return a;
    }

    private long[] nal(int n) throws IOException {
        long[] a = new long[n];
        for (int i = 0; i < n; i++) a[i] = nextLong();
        return a;
    }

    int nextInt() throws IOException {
        return parseInt(next());
    }

    long nextLong() throws IOException {
        return parseLong(next());
    }

    double nextDouble() throws IOException {
        return parseDouble(next());
    }

    String next() throws IOException {
        while (tok == null || !tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    public static void main(String[] args) throws Exception {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(new OutputStreamWriter(System.out));
            //long lStartTime = System.currentTimeMillis();
            new A().solve();
            //long lEndTime = System.currentTimeMillis();
            //out.println("Elapsed time in seconds: " + (double)(lEndTime - lStartTime) / 1000.0);
            in.close();
            out.close();
        } catch (Throwable e) {
            e.printStackTrace();
            exit(1);
        }
    }
}


import java.util.Scanner;

public class Main{

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);			//文字の入力
		int n =sc.nextInt();
		int x = sc.nextInt();
		int y = sc.nextInt();
		int[] d = new int[n];
		for(int i= 0;i < n;i++){
			d[i] = sc.nextInt();
		}
		int ans = 0;
		if(x > y){
			ans = n;
		}
		if(x == y){
			int count = 0;
			for(int i = 0;i < n;i++){
				if(d[i] <= x){
					count++;
				}
			}
			ans = (count+1)/2;
		}
		if(x < y){
			int count = 0;
			for(int i = 0;i < n;i++){
				if(d[i] <= x){
					count++;
				}
			}
			ans = (count+1)/2;
		}

		System.out.println(ans);

	}
}

class Pair implements Comparable{
	int from;		//p
	int end;		//y
	int num;
	int bango;
	@Override
	public int compareTo(Object other) {
		Pair otherpair = (Pair)other;

		return end - otherpair.end;
	}
}


import java.util.Scanner;

public class Main{

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);			//文字の入力
		int n =sc.nextInt();
		int x = sc.nextInt();
		int y = sc.nextInt();
		int[] d = new int[n];
		for(int i= 0;i < n;i++){
			d[i] = sc.nextInt();
		}
		int ans = 0;
		for(int i = 0;i < n;i++){
			if(x > y){
				ans++;
			}else if(x == y){
				if(d[i] <= x){
					ans ++;
				}else{
					break;
				}
			}else{
				if(d[i] <= x){
					ans++;
				}else{
					break;
				}
			}
		}
		System.out.println(ans);

	}
}

class Pair implements Comparable{
	int from;		//p
	int end;		//y
	int num;
	int bango;
	@Override
	public int compareTo(Object other) {
		Pair otherpair = (Pair)other;

		return end - otherpair.end;
	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.StringTokenizer;

public class codee {

	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader  br= new BufferedReader(new InputStreamReader( System.in));
		Scanner sc =new Scanner(System.in);
		StringTokenizer st=new StringTokenizer(br.readLine());
		int n =Integer.parseInt(st.nextToken());
		int x=Integer.parseInt(st.nextToken());
		int y=Integer.parseInt(st.nextToken());
		Integer[] a=new Integer[n];
		st=new StringTokenizer(br.readLine());
		int c=0;
		for(int i=0;i<n;i++) {
			a[i]=Integer.parseInt(st.nextToken());
			if(a[i]<=x)
				c++;
		}
		if(x>y)
			System.out.println(n);
		else {
			System.out.println((c+1)/2);
		}

	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.StringTokenizer;

public class codee {

	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader  br= new BufferedReader(new InputStreamReader( System.in));
		Scanner sc =new Scanner(System.in);
		StringTokenizer st=new StringTokenizer(br.readLine());
		int n =Integer.parseInt(st.nextToken());
		int x=Integer.parseInt(st.nextToken());
		int y=Integer.parseInt(st.nextToken());
		Integer[] a=new Integer[n];
		st=new StringTokenizer(br.readLine());
		for(int i=0;i<n;i++) {
			a[i]=Integer.parseInt(st.nextToken());
		}
		if(x>y)
			System.out.println(n);
		else {
			Arrays.sort(a);
			int i=0;
			int c=0;
			while(a[i]<=x) {
				c++;
				i+=2;
			}
			System.out.println(c);
		}

	}
}


import java.util.*;
import java.io.*;

public class C915 {

	public static void main(String args[])  throws Exception{
		Scanner sc = new Scanner(System.in);
		//Reader sc = new Reader();
		int n = sc.nextInt();
		long x = sc.nextInt();
		long y = sc.nextInt();
		long a[] = new long[n];
		for(int i=0;i<n;i++)
		     a[i] = sc.nextInt();

		Arrays.sort(a);
		int ind = bs(a , x , n) + 1;
		if(x > y)
		     System.out.println(n);
		else if(x <= y){
		     //System.out.println(ind);
		     int ans = ind / 2;
		     if(ind % 2 == 1)
		          ans++;
		     System.out.println(ans);
		}
	}

	static int bs(long a[] , long x , int n){
	     int l = 0 , h = n - 1 , mid = (l + h)/2 , ans = l;

	     while(l <= h){
	          mid = (l + h)/2;

	          if(a[mid] <= x){
	               ans = mid;
	               l = mid + 1;
		     //System.out.println(l +" " +h +" " +mid +"  hii");
	          }
	          else
	               h = mid - 1;
		     //System.out.println(l +" " +h +" " +mid);

	     }

	     return ans;
	}

static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
}


import java.util.*;
import java.io.*;

public class C915 {

	public static void main(String args[])  throws Exception{
		Scanner sc = new Scanner(System.in);
		//Reader sc = new Reader();
		int n = sc.nextInt();
		long x = sc.nextInt();
		long y = sc.nextInt();
		long a[] = new long[n];
		for(int i=0;i<n;i++)
		     a[i] = sc.nextInt();

		Arrays.sort(a);
		int ind = bs(a , x , n) + 1;
		if(ind == 1  &&  a[0] > x)             ind = 0;
		if(x > y)
		     System.out.println(n);
		else if(x <= y){
		     //System.out.println(ind);
		     int ans = ind / 2;
		     if(ind % 2 == 1)
		          ans++;
		     System.out.println(ans);
		}
	}

	static int bs(long a[] , long x , int n){
	     int l = 0 , h = n - 1 , mid = (l + h)/2 , ans = l;

	     while(l <= h){
	          mid = (l + h)/2;

	          if(a[mid] <= x){
	               ans = mid;
	               l = mid + 1;
		     //System.out.println(l +" " +h +" " +mid +"  hii");
	          }
	          else
	               h = mid - 1;
		     //System.out.println(l +" " +h +" " +mid);

	     }

	     return ans;
	}

static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
}


import java.util.*;
import java.io.*;

public class C915 {

	public static void main(String args[])  throws Exception{
		Scanner sc = new Scanner(System.in);
		//Reader sc = new Reader();
		int n = sc.nextInt();
		long x = sc.nextInt();
		long y = sc.nextInt();
		long a[] = new long[n];
		for(int i=0;i<n;i++)
		     a[i] = sc.nextInt();

		Arrays.sort(a);
		int ind = bs(a , x , n) + 1;
		if(ind == 1)             ind = 0;
		if(x > y)
		     System.out.println(n);
		else if(x <= y){
		     //System.out.println(ind);
		     int ans = ind / 2;
		     if(ind % 2 == 1)
		          ans++;
		     System.out.println(ans);
		}
	}

	static int bs(long a[] , long x , int n){
	     int l = 0 , h = n - 1 , mid = (l + h)/2 , ans = l;

	     while(l <= h){
	          mid = (l + h)/2;

	          if(a[mid] <= x){
	               ans = mid;
	               l = mid + 1;
		     //System.out.println(l +" " +h +" " +mid +"  hii");
	          }
	          else
	               h = mid - 1;
		     //System.out.println(l +" " +h +" " +mid);

	     }

	     return ans;
	}

static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
}


import java.util.*;
import java.io.*;

public class C915 {

	public static void main(String args[])  throws Exception{
		Scanner sc = new Scanner(System.in);
		//Reader sc = new Reader();
		int n = sc.nextInt();
		long x = sc.nextInt();
		long y = sc.nextInt();
		long a[] = new long[n];
		for(int i=0;i<n;i++)
		     a[i] = sc.nextInt();

		Arrays.sort(a);
		int ind = Arrays.binarySearch(a , x);
		if(x > y)
		     System.out.println(n);
		else if(x <= y){
		     if(ind < 0)         ind = -1 * (ind + 1);

		     //System.out.println(ind);
		     int ans = ind / 2;
		     if(ind % 2 == 1)
		          ans++;
		     System.out.println(ans);
		}
		else{
		     PriorityQueue<Long> pq = new PriorityQueue<Long>();

		}
	}

static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
}


import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner entrada = new Scanner(System.in);
        int A = entrada.nextInt();
		int B = entrada.nextInt();
		int C = entrada.nextInt();
		int[] array = new int[A];
		Vector<Integer> list = new Vector<>();

		for(int i = 0; i<A; i++){
			array[i] = entrada.nextInt();

			if(array[i] <= B) list.add(array[i]);
		}

		if(B>C) System.out.println(A);
		else{
			int result = list.size()/2;

			if(list.size()%2>0) result += 1;

			System.out.println(result);
		}
    }
}


import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner entrada = new Scanner(System.in);
        int A = entrada.nextInt();
		int B = entrada.nextInt();
		int C = entrada.nextInt();
		int[] array = new int[A];

		for(int i = 0; i<A; i++){
			array[i] = entrada.nextInt();
		}

		if(B<=C) System.out.println("2");
		else System.out.println(A);
    }
}


import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner entrada = new Scanner(System.in);
        int A = entrada.nextInt();
		int B = entrada.nextInt();
		int C = entrada.nextInt();
		int array = new int[A];

		for(int i = 0; i<A; i++){
			array[i] = entrada.nextInt();
		}

		if(B>=C) System.out.println("2");
		else System.out.println(A);
    }
}


import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner entrada = new Scanner(System.in);
        int A = entrada.nextInt();
		int B = entrada.nextInt();
		int C = entrada.nextInt();
		int[] array = new int[A];
		boolean hasMenor = true;

		for(int i = 0; i<A; i++){
			array[i] = entrada.nextInt();

			if(array[i]<=B) hasMenor = true;
		}

		if(B<=C) System.out.println("2");
		else if(hasMenor) System.out.println("1");
		else System.out.println(A);
    }
}


import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner entrada = new Scanner(System.in);
        int A = entrada.nextInt();
		int B = entrada.nextInt();
		int C = entrada.nextInt();
		int[] array = new int[A];

		for(int i = 0; i<A; i++){
			array[i] = entrada.nextInt();
		}

		if(B>=C) System.out.println("2");
		else System.out.println(A);
    }
}


//package acm;

import java.util.*;
import java.io.*;

public class first {
	static PrintWriter out;

	public static void main(String[] args) throws IOException, InterruptedException {
		out = new PrintWriter(System.out);
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int x = sc.nextInt();
		int y = sc.nextInt();
		int[] arr = new int[n];
		for (int i = 0; i < n; i++) {
			arr[i] = sc.nextInt();
		}
		Arrays.sort(arr);
		int u = 0;
		int g = 1;
		int c = 0;
		if (x > y) {
			out.println(n);
		} else {
			for (int i = 0; i < n; i++) {
				if (i % 2 == 0) {
					if(arr[u]<x) {
					arr[u] = Math.max(0, arr[u] - x);
					c+=1;}
					u++;
				} else {
					if (arr[g]<x&&arr[g]!=0)
						arr[g] = arr[g] + y;
					g++;
				}
			}
			c++;
			out.println(c);
		}

		out.flush();
		out.close();
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public Scanner(FileReader r) {
			br = new BufferedReader(r);
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}
}


//package acm;

import java.util.*;
import java.io.*;

public class first {
	static PrintWriter out;

	public static void main(String[] args) throws IOException, InterruptedException {
		out = new PrintWriter(System.out);
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int x = sc.nextInt();
		int y = sc.nextInt();
		int[] arr = new int[n];
		for (int i = 0; i < n; i++) {
			arr[i] = sc.nextInt();
		}
		Arrays.sort(arr);
		int u = 0;
		int g = 1;
		int c = 0;
		if (x > y) {
			out.println(n);
		} else {
			for (int i = 0; i < n; i++) {
//				if (i % 2 == 0) {
//					if(arr[u]<x) {
//					arr[u] = 0;
//					c+=1;u++;}
//					else {
//						arr[u] = Math.max(0, arr[u] - x);
//						u++;
//					}
//
//				} else {
//					if (arr[g]<x&&arr[g]!=0)
//						{arr[g] = arr[g] + y;
//					    g++;}
//				}
//				out.println(Arrays.toString(arr)+" "+x);
//			}
//			//c++;
			if(arr[i]<=x)
				u++;
			}
			if(u%2==0) {
			out.println(u/2);}
			else {
				u+=1;
				out.println(u/2);
			}
		}

		out.flush();
		out.close();
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public Scanner(FileReader r) {
			br = new BufferedReader(r);
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}
}


import java.util.*;
public class qc{
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=sc.nextInt();
    int y=sc.nextInt();
    int a[]=new int[n];
    for(int i=0;i<n;i++){
      a[i]=sc.nextInt();
    }
    Arrays.sort(a);
    int r=0;
    if(x>y)System.out.println(n);
    else{
      while(r<n && a[r]<=x)r++;
      System.out.println(r/2+(r%2));
    }
  }
}