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] * 2;// double for binary search
		int s2 = in[2] * 2;
		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] * 2);
		}
		Arrays.sort(a);
		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(0, reqVal + reqVal % 2 - 1));
				int low = 1;// inclusive bound
				int high = a.length - k1;// 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 (a[index].value >= (s2 + k2 - 1) / k2) {
						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 && a[index].value >= (s2 + k2 - 1) / k2) {
							possible = true;
							low = high;
						}
					}
				}
				if (possible) {
					System.out.println("Yes");
					System.out.println(k1 + " " + k2);
					StringBuilder sb = new StringBuilder(""+a[lowestInd].index);
					for (int j = lowestInd+1; j < lowestInd + k1; j++) {
						sb.append(" " + a[j].index);
					}
					System.out.println(sb);
					sb = new StringBuilder();
					for (int j = a.length-1; j >= a.length - k2; j--) {
						if(j!=a.length-1) {
							sb.append(" ");
						}
						if (j < lowestInd+k1) {
							sb.append( a[j - k1].index);
						} else {
							sb.append( a[j].index);
						}
					}
					System.out.println(sb);
					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) {
			return this.value - e.value;
		}

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