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

//http://codeforces.com/contest/967/problem/D
public class ResourceDistFast {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int[] in = Arrays.stream(br.readLine().split(" ")).mapToInt(x -> Integer.parseInt(x)).toArray();
		int s1 = in[1];
		int s2 = in[2];
		boolean swap = false;
		int[] ain = Arrays.stream(br.readLine().split(" ")).mapToInt(x -> Integer.parseInt(x)).toArray();
		Element[] a = new Element[ain.length];
		for (int i = 1; i <= a.length; i++) {
			a[i - 1] = new Element(i, ain[i - 1]);
		}
		Arrays.sort(a);
		for (int sw = 0; sw < 2; sw++) {
			swap = !swap;
			int temp = s1;
			s1 = s2;
			s2 = temp;
			for (int k1 = 1; k1 <= a.length; k1++) {
				int ind = a.length - k1;
				// check if possible
				int reqVal = (s1 + k1 - 1) / k1;
				if (a[ind].value >= reqVal) {
					// find lowest ind for which it is possible
					int lowestInd = -1 - Arrays.binarySearch(a, new Element(-1, reqVal));
					int low = 1;// inclusive bound
					int high = a.length - k1 + 1;// exclusive bound
					int k2 = -1;
					boolean possible = false;
					while (low < high) {
						k2 = (low + high) / 2;
						low = k2 + 1;
						int index = a.length - k2 - k1;
						if (index >= lowestInd) {
							index += k1;
						}
						// check if possible
						if (1L * a[index].value * k2 >= s2) {
							possible = true;
							low = high;
						} else {// we need at least ceil(s2 / a[index]) elements to include a[index].
								// If impossible, too low. otherwise, valid ans found
							k2 = (s2 + a[index].value - 1) / a[index].value;
							index = a.length - k2 - k1;
							if (index > lowestInd + k1) {
								index += k1;
							}
							if (index >= 0 && 1L * a[index].value * k2 >= s2) {
								possible = true;
								low = high;
							}
						}
					}
					if (possible) {
						System.out.println("Yes");
						if (swap) {
							System.out.println(k2 + " " + k1);
						} else {
							System.out.println(k1 + " " + k2);
						}
						StringBuilder sb1 = new StringBuilder("" + a[lowestInd].index);
						for (int j = lowestInd + 1; j < lowestInd + k1; j++) {
							sb1.append(" " + a[j].index);
						}
						StringBuilder sb2 = new StringBuilder();
						for (int j = a.length - 1; j >= a.length - k2; j--) {
							if (j != a.length - 1) {
								sb2.append(" ");
							}
							if (j < lowestInd + k1) {
								sb2.append(a[j - k1].index);
							} else {
								sb2.append(a[j].index);
							}
						}
						if (!swap) {
							System.out.println(sb1);
							System.out.println(sb2);
						} else {
							System.out.println(sb2);
							System.out.println(sb1);
						}
						return;
					}

				}
			}
		}
		System.out.println("No");
	}

	// https://stackoverflow.com/questions/42399853/sorting-an-array-and-keeping-original-index
	public static class Element implements Comparable<Element> {
		int index, value;

		Element(int index, int value) {
			this.index = index;
			this.value = value;
		}

		public int compareTo(Element e) {
			if (this.value - e.value == 0) {
				return this.index - e.index;
			} else {
				return this.value - e.value;
			}
		}

		public String toString() {
			return this.value + "";
		}
	}
}
