#include<complex>
#include <vector>
#include <algorithm>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <string>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <limits>
#include <climits>
#include <time.h>
#include <cstdio>
#include <numeric>
#define LL long long
#define LD long double
#define rei(x) scanf("%d",&x)
#define reii(x,y) scanf("%d%d",&x,&y)
#define reiii(x,y,z) scanf("%d%d%d",&x,&y,&z)

#define rel(x) scanf("%I64d",&x);
#include<complex>
#include <vector>
#include <algorithm>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <string>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <limits>
#include <climits>
#include <time.h>
#include <cstdio>
#include <numeric>
#define LL long long
#define LD long double
#define rei(x) scanf("%d",&x)
#define reii(x,y) scanf("%d%d",&x,&y)
#define reiii(x,y,z) scanf("%d%d%d",&x,&y,&z)

#define rel(x) scanf("%I64d",&x);

#define ref(x) scanf("%lf",&x)
#define rec(x) scanf("%c",&x)
#define res(x) scanf("%s",x)
#define reli(x) scanf("%[^\n]s", x)
#define fi first
#define se second
#define pb push_back
#define f(i, a, b) for(int i = a; i <= b; i++)
#define ms(Arr) memset(Arr,0,sizeof(Arr));
#define CLR(arr,val)  memset(arr,val,sizeof(arr))
#define bit(a , b) (((a)>>(b))&1)
#define fin freopen("in.txt","r",stdin)
#define fout freopen("out.txt","w",stdout)
#define fout1 freopen("out1.txt","w",stdout)
#define ftest freopen("in.txt","w",stdout)
#define lson (id << 1)
#define rson (id << 1 | 1)
#define ls (i << 1)
#define rs (i << 1 | 1)
using namespace std;
const int INF = 0x3f3f3f3f;
const LL mod = 1000000007;
const double e = 2.718281828459;
typedef pair<int, int> Pii;
typedef pair<LL, LL> Pll;

LL gcd(LL a, LL b)
{
	if (!b)return a;
	return gcd(b, a%b);
}

LL gcd1(int a, int b)
{
	if (!b)return a;
	return gcd(b, a%b);
}

LL pow_mod(LL a, LL b, LL c)
{
	LL ans = 1;
	a = a % c;
	while (b > 0)
	{
		if (b % 2 == 1)
			ans = (ans * a) % c;
		b = b / 2;
		a = (a * a) % c;
	}
	return ans;
}

int pow_int(int a, int b)
{
	int ans = 1;
	while (b > 0)
	{
		if (b % 2 == 1)
			ans = ans * a;
		b = b / 2;
		a = a * a;
	}
	return ans;
}

LL pow_llong(LL a, LL b)
{
	LL ans = 1;
	while (b > 0)
	{
		if (b % 2 == 1)
			ans = ans * a;
		b = b / 2;
		a = a * a;
	}
	return ans;
}

const int dx[9] = { 0, 1, 1, 1, 0,-1,-1,-1, 0 };
const int dy[9] = { 0, 1, 0,-1,-1,-1, 0, 1, 1 };

int Scan()
{
	int res = 0, flag = 0;
	char ch;
	if ((ch = getchar()) == '-')
	{
		flag = 1;
	}
	else if (ch >= '0' && ch <= '9')
	{
		res = ch - '0';
	}
	while ((ch = getchar()) >= '0' && ch <= '9')
	{
		res = res * 10 + (ch - '0');
	}
	return flag ? -res : res;
}

void Out(int a)
{
	if (a < 0)
	{
		putchar('-');
		a = -a;
	}
	if (a >= 10)
	{
		Out(a / 10);
	}
	putchar(a % 10 + '0');
}

LL jc_mod(LL a, LL b, LL mod)
{
	LL ans = 1;
	b = max(b, a - b);
	for (LL i = a; i > b; i--)
	{
		ans *= i;
		ans %= mod;
	}
	return ans;
}

double lg(double a)
{
	return (log(a) / log(10.0));
}

int lowbit(int x)
{
	return x & -x;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//long long：-9223372036854775808~9223372036854775807
//int：-2147483648~2147483647
//double：-1.7*10^-308~1.7*10^308，15~16位有效数字
//long double：-1.2*10^-4932~1.2*10^4932，18~19位有效数字
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

inline int read()
{
	int f = 1, x = 0; char ch = getchar();
	while (ch<'0' || ch>'9') { if (ch == '-')f = -1; ch = getchar(); }
	while (ch >= '0'&&ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
	return x*f;
}

/*******************************************************
自定义结构体排序
struct Struct_Name
{
int variable;
bool operator <(const Struct_Name &other)const   //升序排序
{
return variable > other.variable;
}
};
*******************************************************/

//离散化///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//离散化///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//离散化///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define MAXNN 100010
void lisan(int *x, int n) {
	//首先c++调用一个数组直接打这个数组的类型就好了。
	int data[MAXNN];
	f(i, 1, n)data[i] = x[i];
	sort(data + 1, data + 1 + n);//排序是肯定要的。
	int o = unique(data + 1, data + 1 + n) - data - 1;//给data数组[1..n]去重，黑科技
	f(i, 1, n)x[i] = lower_bound(data + 1, data + 1 + o, x[i]) - data;//找到x[i]在data中的位置再赋值为这个位置，如果不-data就是返回这个值。
}
////////////////////////////////////////////////////end/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////end/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////end/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////三分框架 左闭右开////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////三分框架 左闭右开////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////三分框架 左闭右开////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
LL calc(int M)
{
	return 1;
}
int sanfen(int L, int R)
{
	int M, RM;
	while (L + 1 < R)
	{
		M = (L + R) / 2;
		RM = (M + R) / 2;
		if (calc(M) < calc(RM)) //计算最小值,若为最大值则>
			R = RM;
		else
			L = M;
	}
	return L;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int CaculateWeekDay(int y, int m, int d)
{
	if (m == 1 || m == 2) {
		m += 12;
		y--;
	}
	int iWeek = (d + 2 * m + 3 * (m + 1) / 5 + y + y / 4 - y / 100 + y / 400) % 7;
	return iWeek;
}

////////////////////////////////////////////////////e nd/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////end/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////end/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

pair<LL,int> a[300100];

int main()
{
	int n;
	LL x1, x2;
	rei(n);
	rel(x1);
	rel(x2);
	f(i, 1, n)
	{
		rel(a[i].first);
		a[i].second = i;
	}
	sort(a + 1, a + 1 + n);

	for (int i = 1; i <= n; i++)
	{
		double t = x1 * 1.0 / i;
		if (t > a[n].first)
			continue;
		int l = 1, r = n;
		while (r > l)
		{
			int mid = (l + r) >> 1;
			if (a[mid].first >= t)
				r = mid;
			else
				l = mid + 1;
		}
		int pos = l;
		if (pos + i - 1> n)
			continue;
		if ((n - pos - i + 1) && (a[pos + i].first * (n - pos - i + 1) >= x2))
		{
			printf("Yes\n");
			printf("%d %d\n", i, (n - pos - i + 1));
			f(j, pos, pos + i - 1)
			{
				printf("%d ", a[j].second);
			}
			printf("\n");
			f(j, pos + i, n)
			{
				printf("%d ", a[j].second);
			}
			printf("\n");
			return 0;
		}
	}

	LL t = x1;
	x1 = x2;
	x2 = t;
	for (int i = 1; i <= n; i++)
	{
		double t = x1 * 1.0 / i;
		if (t > a[n].first)
			continue;
		int l = 1, r = n;
		while (r > l)
		{
			int mid = (l + r) >> 1;
			if (a[mid].first >= t)
				r = mid;
			else
				l = mid + 1;
		}
		int pos = l;
		if (pos + i - 1> n)
			continue;
		if ((n - pos - i + 1) && (a[pos + i].first * (n - pos - i + 1) >= x2))
		{
			printf("Yes\n");
			printf("%d %d\n",  (n - pos - i + 1), i);
			f(j, pos + i, n)
			{
				printf("%d ", a[j].second);
			}
			printf("\n");
			f(j, pos, pos + i - 1)
			{
				printf("%d ", a[j].second);
			}
			printf("\n");
			return 0;
		}
	}
	printf("No\n");

	return 0;
}


#include<complex>
#include <vector>
#include <algorithm>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <string>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <limits>
#include <climits>
#include <time.h>
#include <cstdio>
#include <numeric>
#define LL long long
#define LD long double
#define rei(x) scanf("%d",&x)
#define reii(x,y) scanf("%d%d",&x,&y)
#define reiii(x,y,z) scanf("%d%d%d",&x,&y,&z)

#define rel(x) scanf("%I64d",&x);
#include<complex>
#include <vector>
#include <algorithm>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <string>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <limits>
#include <climits>
#include <time.h>
#include <cstdio>
#include <numeric>
#define LL long long
#define LD long double
#define rei(x) scanf("%d",&x)
#define reii(x,y) scanf("%d%d",&x,&y)
#define reiii(x,y,z) scanf("%d%d%d",&x,&y,&z)

#define rel(x) scanf("%I64d",&x);

#define ref(x) scanf("%lf",&x)
#define rec(x) scanf("%c",&x)
#define res(x) scanf("%s",x)
#define reli(x) scanf("%[^\n]s", x)
#define fi first
#define se second
#define pb push_back
#define f(i, a, b) for(int i = a; i <= b; i++)
#define ms(Arr) memset(Arr,0,sizeof(Arr));
#define CLR(arr,val)  memset(arr,val,sizeof(arr))
#define bit(a , b) (((a)>>(b))&1)
#define fin freopen("in.txt","r",stdin)
#define fout freopen("out.txt","w",stdout)
#define fout1 freopen("out1.txt","w",stdout)
#define ftest freopen("in.txt","w",stdout)
#define lson (id << 1)
#define rson (id << 1 | 1)
#define ls (i << 1)
#define rs (i << 1 | 1)
using namespace std;
const int INF = 0x3f3f3f3f;
const LL mod = 1000000007;
const double e = 2.718281828459;
typedef pair<int, int> Pii;
typedef pair<LL, LL> Pll;

LL gcd(LL a, LL b)
{
	if (!b)return a;
	return gcd(b, a%b);
}

LL gcd1(int a, int b)
{
	if (!b)return a;
	return gcd(b, a%b);
}

LL pow_mod(LL a, LL b, LL c)
{
	LL ans = 1;
	a = a % c;
	while (b > 0)
	{
		if (b % 2 == 1)
			ans = (ans * a) % c;
		b = b / 2;
		a = (a * a) % c;
	}
	return ans;
}

int pow_int(int a, int b)
{
	int ans = 1;
	while (b > 0)
	{
		if (b % 2 == 1)
			ans = ans * a;
		b = b / 2;
		a = a * a;
	}
	return ans;
}

LL pow_llong(LL a, LL b)
{
	LL ans = 1;
	while (b > 0)
	{
		if (b % 2 == 1)
			ans = ans * a;
		b = b / 2;
		a = a * a;
	}
	return ans;
}

const int dx[9] = { 0, 1, 1, 1, 0,-1,-1,-1, 0 };
const int dy[9] = { 0, 1, 0,-1,-1,-1, 0, 1, 1 };

int Scan()
{
	int res = 0, flag = 0;
	char ch;
	if ((ch = getchar()) == '-')
	{
		flag = 1;
	}
	else if (ch >= '0' && ch <= '9')
	{
		res = ch - '0';
	}
	while ((ch = getchar()) >= '0' && ch <= '9')
	{
		res = res * 10 + (ch - '0');
	}
	return flag ? -res : res;
}

void Out(int a)
{
	if (a < 0)
	{
		putchar('-');
		a = -a;
	}
	if (a >= 10)
	{
		Out(a / 10);
	}
	putchar(a % 10 + '0');
}

LL jc_mod(LL a, LL b, LL mod)
{
	LL ans = 1;
	b = max(b, a - b);
	for (LL i = a; i > b; i--)
	{
		ans *= i;
		ans %= mod;
	}
	return ans;
}

double lg(double a)
{
	return (log(a) / log(10.0));
}

int lowbit(int x)
{
	return x & -x;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//long long：-9223372036854775808~9223372036854775807
//int：-2147483648~2147483647
//double：-1.7*10^-308~1.7*10^308，15~16位有效数字
//long double：-1.2*10^-4932~1.2*10^4932，18~19位有效数字
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

inline int read()
{
	int f = 1, x = 0; char ch = getchar();
	while (ch<'0' || ch>'9') { if (ch == '-')f = -1; ch = getchar(); }
	while (ch >= '0'&&ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
	return x*f;
}

/*******************************************************
自定义结构体排序
struct Struct_Name
{
int variable;
bool operator <(const Struct_Name &other)const   //升序排序
{
return variable > other.variable;
}
};
*******************************************************/

//离散化///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//离散化///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//离散化///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define MAXNN 100010
void lisan(int *x, int n) {
	//首先c++调用一个数组直接打这个数组的类型就好了。
	int data[MAXNN];
	f(i, 1, n)data[i] = x[i];
	sort(data + 1, data + 1 + n);//排序是肯定要的。
	int o = unique(data + 1, data + 1 + n) - data - 1;//给data数组[1..n]去重，黑科技
	f(i, 1, n)x[i] = lower_bound(data + 1, data + 1 + o, x[i]) - data;//找到x[i]在data中的位置再赋值为这个位置，如果不-data就是返回这个值。
}
////////////////////////////////////////////////////end/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////end/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////end/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////三分框架 左闭右开////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////三分框架 左闭右开////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////三分框架 左闭右开////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
LL calc(int M)
{
	return 1;
}
int sanfen(int L, int R)
{
	int M, RM;
	while (L + 1 < R)
	{
		M = (L + R) / 2;
		RM = (M + R) / 2;
		if (calc(M) < calc(RM)) //计算最小值,若为最大值则>
			R = RM;
		else
			L = M;
	}
	return L;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int CaculateWeekDay(int y, int m, int d)
{
	if (m == 1 || m == 2) {
		m += 12;
		y--;
	}
	int iWeek = (d + 2 * m + 3 * (m + 1) / 5 + y + y / 4 - y / 100 + y / 400) % 7;
	return iWeek;
}

////////////////////////////////////////////////////e nd/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////end/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////end/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

pair<LL,int> a[300100];

int main()
{
	int n;
	LL x1, x2;
	rei(n);
	rel(x1);
	rel(x2);
	f(i, 1, n)
	{
		rel(a[i].first);
		a[i].second = i;
	}
	sort(a + 1, a + 1 + n);

	for (int i = 1; i <= n; i++)
	{
		double t = x1 * 1.0 / i;
		if (t > a[n].first)
			continue;
		int l = 1, r = n;
		while (r > l)
		{
			int mid = (l + r) >> 1;
			if (a[mid].first >= t)
				r = mid;
			else
				l = mid + 1;
		}
		int pos = l;
		if (pos + i - 1> n)
			continue;
		if ((n-pos-i+1) && (a[pos + i].first >= x2 / (n - pos - i + 1)))
		{
			printf("Yes\n");
			printf("%d %d\n", i, (n - pos - i + 1));
			f(j, pos, pos + i - 1)
			{
				printf("%d ", a[j].second);
			}
			printf("\n");
			f(j, pos + i, n)
			{
				printf("%d ", a[j].second);
			}
			printf("\n");
			return 0;
		}
	}

	LL t = x1;
	x1 = x2;
	x2 = t;
	for (int i = 1; i <= n; i++)
	{
		double t = x1 * 1.0 / i;
		if (t > a[n].first)
			continue;
		int l = 1, r = n;
		while (r > l)
		{
			int mid = (l + r) >> 1;
			if (a[mid].first >= t)
				r = mid;
			else
				l = mid + 1;
		}
		int pos = l;
		if (pos + i - 1> n)
			continue;
		if ((n - pos - i + 1) && (a[pos + i].first * (n - pos - i + 1) >= x2))
		{
			printf("Yes\n");
			printf("%d %d\n",  (n - pos - i + 1), i);
			f(j, pos + i, n)
			{
				printf("%d ", a[j].second);
			}
			printf("\n");
			f(j, pos, pos + i - 1)
			{
				printf("%d ", a[j].second);
			}
			printf("\n");
			return 0;
		}
	}
	printf("No\n");

	return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define con continue
#define bk break
#define LL long long
#define db double
#define pt cout<<'\n';
#define ms(a, b) memset((a), (b), sizeof(a))
#define mp make_pair
#define endl '\n'
LL inf=2147483647;const long long ll =9223372036854775807,ninf=1000000000;const double eps = 1e-6; const long long nll =1000000000000000000;
#define sz size()
#define len(X) strlen(X)
#define IOS ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define ULL unsigned long long
#define de cout<<"test"<<endl;
#define st system("pause");
#define F first
#define S second
LL n,b,c;
pair<LL,LL>A[100005]={};
int main()
{

while(cin>>n>>b>>c){

    for(int i=1;i<=n;i++){
        cin>>A[i].F;
        A[i].S=i;
    }
    sort(A+1,A+1+n);

    int no=0,t1;
    int i,j;
    for(i=n;i>=1&&(n-i+1)*A[i].F<c;i--);

    if(i==0)
        no=1;

    for(int j=i;j>=1&&(i-j)*A[j].F<b;j--);

    if(j==0)
        no=1;

    if(!no){
            cout<<"YES"<<endl;
    cout<<i-j<<" "<<n-i+1<<endl;

    for(int k=j;k<=i;k++)
        cout<<A[k].S<<" ";

    pt

    for(int k=n-i+1;k<=n;k++)
        cout<<A[k].S<<" ";

    pt

    return 0;
    }

    no=0;

        for(i=n;i>=1&&(n-i+1)*A[i].F<b;i--);

    if(i==0)
        no=1;

    for(int j=i;j>=1&&(i-j)*A[j].F<c;j--);

    if(j==0)
        no=1;

    if(!no){
           cout<<"YES"<<endl;
    cout<<n-i+1<<" "<<i-j<<endl;

    for(int k=n-i+1;k<=n;k++)
        cout<<A[k].S<<" ";

    pt;

        for(int k=j;k<=i;k++)
        cout<<A[k].S<<" ";

    pt;

    }

    cout<<"NO"<<endl;

}
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define con continue
#define bk break
#define LL long long
#define db double
#define pt cout<<'\n';
#define ms(a, b) memset((a), (b), sizeof(a))
#define mp make_pair
#define endl '\n'
LL inf=2147483647;const long long ll =9223372036854775807,ninf=1000000000;const double eps = 1e-6; const long long nll =1000000000000000000;
#define sz size()
#define len(X) strlen(X)
#define IOS ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define ULL unsigned long long
#define de cout<<"test"<<endl;
#define st system("pause");
#define F first
#define S second
LL n,b,c;
pair<LL,LL>A[100005]={};
int main()
{

while(cin>>n>>b>>c){

    for(int i=1;i<=n;i++){
        cin>>A[i].F;
        A[i].S=i;
    }
    sort(A+1,A+1+n);

    int no=0;
    LL i,j;
    for(i=n;i>=1&&(n-i+1)*A[i].F<c;i--);

    if(i==0)
        no=1;

    for(j=i;j>=1&&(i-j)*A[j].F<b;j--);

    if(j==0)
        no=1;

    if(!no){
            cout<<"Yes"<<endl;
    cout<<i-j<<" "<<n-i+1<<endl;

    for(int k=j;k<i;k++)
        cout<<A[k].S<<" ";

    pt

    for(int k=i;k<=n;k++)
        cout<<A[k].S<<" ";

    pt

    return 0;
    }

    no=0;

        for(i=n;i>=1&&(n-i+1)*A[i].F<b;i--);

    if(i==0)
        no=1;

    for(j=i;j>=1&&(i-j)*A[j].F<c;j--);

    if(j==0)
        no=1;

    if(!no){
           cout<<"Yes"<<endl;
    cout<<n-i+1<<" "<<i-j<<endl;

    for(int k=i;k<=n;k++)
        cout<<A[k].S<<" ";

    pt;

        for(int k=j;k<i;k++)
        cout<<A[k].S<<" ";

    pt;
return 0;
    }

    cout<<"No"<<endl;

}
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define con continue
#define bk break
#define LL long long
#define db double
#define pt cout<<'\n';
#define ms(a, b) memset((a), (b), sizeof(a))
#define mp make_pair
#define endl '\n'
LL inf=2147483647;const long long ll =9223372036854775807,ninf=1000000000;const double eps = 1e-6; const long long nll =1000000000000000000;
#define sz size()
#define len(X) strlen(X)
#define IOS ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define ULL unsigned long long
#define de cout<<"test"<<endl;
#define st system("pause");
#define F first
#define S second
LL n,b,c;
pair<LL,LL>A[100005]={};
int main()
{

while(cin>>n>>b>>c){

    for(int i=1;i<=n;i++){
        cin>>A[i].F;
        A[i].S=i;
    }
    sort(A+1,A+1+n);

    int no=0;
    LL i,j;
    for(i=n;i>=1&&(n-i+1)*A[i].F<c;i--);

    if(i==0)
        no=1;

    for(j=i;j>=1&&(i-j)*A[j].F<b;j--);

    if(j==0)
        no=1;

    if(!no){
            cout<<"Yes"<<endl;
    cout<<i-j<<" "<<n-i+1<<endl;

    for(int k=j;k<i;k++)
        cout<<A[k].S<<" ";

    pt

    for(int k=i;k<=n;k++)
        cout<<A[k].S<<" ";

    pt

    return 0;
    }

    no=0;

        for(i=n;i>=1&&(n-i+1)*A[i].F<b;i--);

    if(i==0)
        no=1;

    for(j=i;j>=1&&(i-j)*A[j].F<c;j--);

    if(j==0)
        no=1;

    if(!no){
           cout<<"Yes"<<endl;
    cout<<n-i+1<<" "<<i-j<<endl;

    for(int k=i;k<=n;k++)
        cout<<A[k].S<<" ";

    pt;

        for(int k=j;k<i;k++)
        cout<<A[k].S<<" ";

    pt;

    }

    cout<<"No"<<endl;

}
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define con continue
#define bk break
#define LL long long
#define db double
#define pt cout<<'\n';
#define ms(a, b) memset((a), (b), sizeof(a))
#define mp make_pair
#define endl '\n'
LL inf=2147483647;const long long ll =9223372036854775807,ninf=1000000000;const double eps = 1e-6; const long long nll =1000000000000000000;
#define sz size()
#define len(X) strlen(X)
#define IOS ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define ULL unsigned long long
#define de cout<<"test"<<endl;
#define st system("pause");
#define F first
#define S second
LL n,b,c;
pair<LL,LL>A[100005]={};
int main()
{

while(cin>>n>>b>>c){

    for(int i=1;i<=n;i++){
        cin>>A[i].F;
        A[i].S=i;
    }
    sort(A+1,A+1+n);

    int no=0,t1;
    int i,j;
    for(i=n;i>=1&&(n-i+1)*A[i].F<c;i--);

    if(i==0)
        no=1;

    for(int j=i;j>=1&&(i-j)*A[i].F<b;j--);

    if(j==0)
        no=1;

    if(!no){
            cout<<"YES"<<endl;
    cout<<i-j<<" "<<n-i+1<<endl;

    for(int k=j;k<=i;k++)
        cout<<A[k].S<<" ";

    pt

    for(int k=n-i+1;k<=n;k++)
        cout<<A[k].S<<" ";

    pt

    return 0;
    }

    no=0;

        for(i=n;i>=1&&(n-i+1)*A[i].F<b;i--);

    if(i==0)
        no=1;

    for(int j=i;j>=1&&(i-j)*A[i].F<c;j--);

    if(j==0)
        no=1;

    if(!no){
           cout<<"YES"<<endl;
    cout<<n-i+1<<" "<<i-j<<endl;

    for(int k=n-i+1;k<=n;k++)
        cout<<A[k].S<<" ";

    pt;

        for(int k=j;k<=i;k++)
        cout<<A[k].S<<" ";

    pt;

    }

    cout<<"NO"<<endl;

}
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define con continue
#define bk break
#define LL long long
#define db double
#define pt cout<<'\n';
#define ms(a, b) memset((a), (b), sizeof(a))
#define mp make_pair
#define endl '\n'
LL inf=2147483647;const long long ll =9223372036854775807,ninf=1000000000;const double eps = 1e-6; const long long nll =1000000000000000000;
#define sz size()
#define len(X) strlen(X)
#define IOS ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define ULL unsigned long long
#define de cout<<"test"<<endl;
#define st system("pause");
#define F first
#define S second
LL n,b,c;
pair<LL,LL>A[100005]={};
int main()
{

while(cin>>n>>b>>c){

    for(int i=1;i<=n;i++){
        cin>>A[i].F;
        A[i].S=i;
    }
    sort(A+1,A+1+n);

    int no=0;
    LL i,j;
    for(i=n;i>=1&&(n-i+1)*A[i].F<c;i--);

    if(i==0)
        no=1;

    for(j=i;j>=1&&(i-j)*A[j].F<b;j--);

    if(j==0)
        no=1;

    if(!no){
            cout<<"YES"<<endl;
    cout<<i-j<<" "<<n-i+1<<endl;

    for(int k=j;k<i;k++)
        cout<<A[k].S<<" ";

    pt

    for(int k=i;k<=n;k++)
        cout<<A[k].S<<" ";

    pt

    return 0;
    }

    no=0;

        for(i=n;i>=1&&(n-i+1)*A[i].F<b;i--);

    if(i==0)
        no=1;

    for(j=i;j>=1&&(i-j)*A[j].F<c;j--);

    if(j==0)
        no=1;

    if(!no){
           cout<<"YES"<<endl;
    cout<<n-i+1<<" "<<i-j<<endl;

    for(int k=i;k<=n;k++)
        cout<<A[k].S<<" ";

    pt;

        for(int k=j;k<i;k++)
        cout<<A[k].S<<" ";

    pt;

    }

    cout<<"NO"<<endl;

}
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define con continue
#define bk break
#define LL long long
#define db double
#define pt cout<<'\n';
#define ms(a, b) memset((a), (b), sizeof(a))
#define mp make_pair
#define endl '\n'
LL inf=2147483647;const long long ll =9223372036854775807,ninf=1000000000;const double eps = 1e-6; const long long nll =1000000000000000000;
#define sz size()
#define len(X) strlen(X)
#define IOS ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define ULL unsigned long long
#define de cout<<"test"<<endl;
#define st system("pause");
#define F first
#define S second
LL n,b,c;
pair<LL,LL>A[100005]={};
int main()
{

while(cin>>n>>b>>c){

    for(int i=1;i<=n;i++){
        cin>>A[i].F;
        A[i].S=i;
    }
    sort(A+1,A+1+n);

    int no=0;
    LL i,j;
    for(i=n;i>=1&&(n-i+1)*A[i].F<c;i--);

    if(i==0)
        no=1;

    for(j=i;j>=1&&(i-j)*A[j].F<b;j--);

    if(j==0)
        no=1;

    if(!no){
            cout<<"YES"<<endl;
    cout<<i-j<<" "<<n-i+1<<endl;

    for(int k=j;k<=i;k++)
        cout<<A[k].S<<" ";

    pt

    for(int k=i;k<=n;k++)
        cout<<A[k].S<<" ";

    pt

    return 0;
    }

    no=0;

        for(i=n;i>=1&&(n-i+1)*A[i].F<b;i--);

    if(i==0)
        no=1;

    for(j=i;j>=1&&(i-j)*A[j].F<c;j--);

    if(j==0)
        no=1;

    if(!no){
           cout<<"YES"<<endl;
    cout<<n-i+1<<" "<<i-j<<endl;

    for(int k=i;k<=n;k++)
        cout<<A[k].S<<" ";

    pt;

        for(int k=j;k<=i;k++)
        cout<<A[k].S<<" ";

    pt;

    }

    cout<<"NO"<<endl;

}
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define con continue
#define bk break
#define LL long long
#define db double
#define pt cout<<'\n';
#define ms(a, b) memset((a), (b), sizeof(a))
#define mp make_pair
#define endl '\n'
LL inf=2147483647;const long long ll =9223372036854775807,ninf=1000000000;const double eps = 1e-6; const long long nll =1000000000000000000;
#define sz size()
#define len(X) strlen(X)
#define IOS ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define ULL unsigned long long
#define de cout<<"test"<<endl;
#define st system("pause");
#define F first
#define S second
LL n,b,c;
pair<LL,LL>A[300005]={};
int main()
{

while(cin>>n>>b>>c){

    for(int i=1;i<=n;i++){
        cin>>A[i].F;
        A[i].S=i;
    }
    sort(A+1,A+1+n);

    int no=0;
    LL i,j;
    for(i=n;i>=1&&(n-i+1)*A[i].F<c;i--);

    if(i==0)
        no=1;

    for(j=i;j>=1&&(i-j)*A[j].F<b;j--);

    if(j==0)
        no=1;

    if(!no){
            cout<<"Yes"<<endl;
    cout<<i-j<<" "<<n-i+1<<endl;

    for(int k=j;k<i;k++)
        cout<<A[k].S<<" ";

    pt

    for(int k=i;k<=n;k++)
        cout<<A[k].S<<" ";

    pt

    return 0;
    }

    no=0;

        for(i=n;i>=1&&(n-i+1)*A[i].F<b;i--);

    if(i==0)
        no=1;

    for(j=i;j>=1&&(i-j)*A[j].F<c;j--);

    if(j==0)
        no=1;

    if(!no){
           cout<<"Yes"<<endl;
    cout<<n-i+1<<" "<<i-j<<endl;

    for(int k=i;k<=n;k++)
        cout<<A[k].S<<" ";

    pt;

        for(int k=j;k<i;k++)
        cout<<A[k].S<<" ";

    pt;
return 0;
    }

    cout<<"No"<<endl;

}
    return 0;
}


// ~/BAU/ACM-ICPC/Teams/Republic_of_Coders/Corvus
// ~/sudo apt-get verdict Accpeted

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <memory.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
const int N = 300001;
const ll MOD = 1e9 + 7;

int n;
ll x1, x2;
vector<pair<ll, int> > ser;

int main() {
#ifndef ONLINE_JUDGE
	freopen("input.in", "r", stdin);
#endif

	scanf("%d%lld%lld", &n, &x1, &x2);
	for (int i = 0, x; i < n; i++) {
		scanf("%d", &x);
		ser.push_back(make_pair(x, i));
	}

	sort(ser.begin(), ser.end());

	int A = -1, B = -1, C = -1;
	for (int i = 1; i < n; i++) {
		ll v1 = (x1 + 1ll * i - 1) / i;

		int a = lower_bound(ser.begin(), ser.end(), make_pair(v1, -1)) - ser.begin();
		if (a == ser.size() || n - a < i) continue;
		int b = a + i - 1;
		int c = (a == 0 ? b + 1 : 0);
		int l = ser[c].first, r = ser[n-1].first, m, k2 = -1;
		while (l <= r) {
			m = (l + r) / 2;
			int k = (x2 + m - 1) / m;
			int c2 = (k <= n - b - 1 ? n - k : a - (k - (n - b - 1)));

			if (k <= n - i) {
				if (ser[c2].first >= m) {
					k2 = k;
					break;
				}
				else r = m - 1;
			}
			else l = m + 1;
		}
		if (k2 != -1) {
			A = a;
			B = b;
			int to_rem = n - i - k2;
			if (c < a) {
				if (a - c >= to_rem) {
					c += to_rem;
					to_rem = 0;
				}
				else {
					to_rem -= a - c;
					c = b + 1;
				}
			}
			c += to_rem;
			C = c;
			break;
		}
	}

	if (A != -1 && B != -1) {
		puts("Yes");
		vector<int> v1, v2;
		for (int i = A; i <= B; i++)
			v1.push_back(ser[i].second);
		if (C < A) {
			for (int i = C; i < A; i++)
				v2.push_back(ser[i].second);
			for (int i = B + 1; i < n; i++)
				v2.push_back(ser[i].second);
		}
		else {
			for (int i = C; i < n; i++)
				v2.push_back(ser[i].second);
		}

		printf("%d %d\n", (int)v1.size(), (int)v2.size());
		for (int i = 0; i < v1.size(); i++)
			printf("%s%d", (i ? " " : ""), v1[i] + 1);
		puts("");
		for (int i = 0; i < v2.size(); i++)
			printf("%s%d", (i ? " " : ""), v2[i] + 1);
		puts("");
	}
	else puts("No");
	return 0;
}


// ~/BAU/ACM-ICPC/Teams/Republic_of_Coders/Corvus
// ~/sudo apt-get verdict Accpeted

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <memory.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
const int N = 300001;
const ll MOD = 1e9 + 7;

int n, x1, x2;
vector<pair<int, int> > v;

int main() {
#ifndef ONLINE_JUDGE
	freopen("input.in", "r", stdin);
#endif

	scanf("%d%d%d", &n, &x1, &x2);
	for (int i = 0, x; i < n; i++) {
		scanf("%d", &x);
		v.push_back(make_pair(x, i + 1));
	}
	sort(v.begin(), v.end());
	for (int j = 0; j < 2; j++) {
		int A = -1, B = -1, C = -1, D = -1;

		for (int i = n - 1; i >= 0; i--) {
			int v2 = (x2 + (n - i) - 1) / (n - i);
			if (v2 <= v[i].first) {
				C = i, D = n - 1;
				break;
			}
		}
		if (C != -1) {
			for (int i = 0; i < C; i++) {
				int v2 = (x1 + (C - i) - 1) / (C - i);
				if (v2 <= v[i].first) {
					A = i;
					B = C - 1;
					break;
				}
			}
		}

		if (A != -1) {
			if (j) {
				swap(A, C);
				swap(B, D);
			}
			puts("Yes");
			printf("%d %d\n", (B - A + 1), (D - C + 1));
			for (int i = A; i <= B; i++)
				printf("%d ", v[i].second);
			puts("");
			for (int i = C; i <= D; i++)
				printf("%d ", v[i].second);
			puts("");
			return 0;
		}

		swap(x1, x2);
	}
	puts("No");
	return 0;
}


// ~/BAU/ACM-ICPC/Teams/Republic_of_Coders/Corvus
// ~/sudo apt-get verdict Accpeted

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <memory.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
const int N = 300001;
const ll MOD = 1e9 + 7;

int n;
ll x1, x2;
vector<pair<ll, int> > ser;

int main() {
#ifndef ONLINE_JUDGE
	freopen("input.in", "r", stdin);
#endif

	scanf("%d%lld%lld", &n, &x1, &x2);
	for (int i = 0, x; i < n; i++) {
		scanf("%d", &x);
		ser.push_back(make_pair(x, i));
	}

	sort(ser.begin(), ser.end());

	int A = -1, B = -1, C = -1;
	for (int i = 1; i < n; i++) {
		ll v1 = (x1 + 1ll * i - 1) / i;

		int a = lower_bound(ser.begin(), ser.end(), make_pair(v1, -1)) - ser.begin();
		if (a == ser.size() || n - a < i) continue;
		int b = a + i - 1;
		int c = (a == 0 ? b + 1 : 0);
		int l = ser[c].first, r = ser[n-1].first, m, k2 = -1;
		//int k2 = (x2 + ser[c].first - 1) / ser[c].first;
		while (l <= r) {
			m = (l + r) / 2;
			int k = (x2 + m - 1) / m;
			if (k <= n - i) {
				k2 = k;
				break;
			}
			else l = m + 1;
		}
		if (k2 != -1) {
			A = a;
			B = b;
			int to_rem = n - i - k2;
			if (c < a) {
				if (a - c >= to_rem) {
					c += to_rem;
					to_rem = 0;
				}
				else {
					to_rem -= a - c;
					c = b + 1;
				}
			}
			c += to_rem;
			C = c;
			break;
		}
	}

	if (A != -1 && B != -1) {
		puts("Yes");
		vector<int> v1, v2;
		for (int i = A; i <= B; i++)
			v1.push_back(ser[i].second);
		if (C < A) {
			for (int i = C; i < A; i++)
				v2.push_back(ser[i].second);
			for (int i = B + 1; i < n; i++)
				v2.push_back(ser[i].second);
		}
		else {
			for (int i = C; i < n; i++)
				v2.push_back(ser[i].second);
		}

		printf("%d %d\n", (int)v1.size(), (int)v2.size());
		for (int i = 0; i < v1.size(); i++)
			printf("%s%d", (i ? " " : ""), v1[i] + 1);
		puts("");
		for (int i = 0; i < v2.size(); i++)
			printf("%s%d", (i ? " " : ""), v2[i] + 1);
		puts("");
	}
	else puts("No");
	return 0;
}


// ~/BAU/ACM-ICPC/Teams/Republic_of_Coders/Corvus
// ~/sudo apt-get verdict Accpeted

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <memory.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
const int N = 300001;
const ll MOD = 1e9 + 7;

int n, x1, x2;
vector<pair<int, int> > v;

int main() {
#ifndef ONLINE_JUDGE
	freopen("input.in", "r", stdin);
#endif

	scanf("%d%d%d", &n, &x1, &x2);
	for (int i = 0, x; i < n; i++) {
		scanf("%d", &x);
		v.push_back(make_pair(x, i));
	}
	sort(v.begin(), v.end());

	int A = -1, B = -1, C = -1, D = -1;
	for (int i = 0; i < n; i++) {
		int k1 = (x1 + v[i].first - 1) / v[i].first;
		if (k1 > n) continue;
		int c = (i ? 0 : i + k1);
		int cnt = (c < i ? n - (i + k1 - 1) - 1 + i - c : n - c);
		int k2 = (x2 + v[c].first - 1) / v[c].first;

		if (k2 <= cnt) {
			A = i;
			B = i + k1 - 1;
			if (c < i) {
				if (i - c >= k2) {
					C = 0;
					D = c + k2 - 1;
				}
				else {
					C = 0;
					D = B + (k2 - i) - 1;
				}
			}
			else {
				C = c;
				D = C + k2 - 1;
			}
			break;
		}
	}

	if (A != -1) {
		puts("Yes");
		printf("%d %d\n", B - A + 1, (C < A ? (D < A ? D - C + 1 : A - C + D - B) : D - C + 1));
		for (int i = A; i <= B; i++)
			printf("%d ", v[i].second + 1);
		puts("");

		for (int i = C; i <= min(A - 1, D); i++)
			printf("%d ", v[i].second + 1);
		if (D > B)
			for (int i = B+1; i <= D; i++)
				printf("%d ", v[i].second + 1);
		puts("");
	}
	else puts("No");
	return 0;
}


// ~/BAU/ACM-ICPC/Teams/Republic_of_Coders/Corvus
// ~/sudo apt-get verdict Accpeted

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <memory.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
const int N = 300001;
const ll MOD = 1e9 + 7;

int n;
ll x1, x2;
vector<pair<ll, int> > ser;

int main() {
#ifndef ONLINE_JUDGE
	freopen("input.in", "r", stdin);
#endif

	scanf("%d%lld%lld", &n, &x1, &x2);
	for (int i = 0, x; i < n; i++) {
		scanf("%d", &x);
		ser.push_back(make_pair(x, i));
	}

	sort(ser.begin(), ser.end());

	int A = -1, B = -1, C = -1;
	for (int i = 1; i < n; i++) {
		ll v1 = (x1 + 1ll * i - 1) / i;

		int a = lower_bound(ser.begin(), ser.end(), make_pair(v1, -1)) - ser.begin();
		if (a == ser.size() || n - a < i) continue;
		int b = a + i - 1;
		int c = (a == 0 ? b + 1 : 0);
		ll k2 = (x2 + 1ll*ser[c].first - 1) / ser[c].first;
		if (k2 <= n - i) {
			A = a;
			B = b;
			int to_rem = n - i - (int)k2;
			if (c < a) {
				if (a - c >= to_rem) {
					c += to_rem;
					to_rem = 0;
				}
				else {
					to_rem -= a - c;
					c = b + 1;
				}
			}
			c += to_rem;
			C = c;
			break;
		}
	}

	if (A != -1 && B != -1) {
		puts("Yes");
		vector<int> v1, v2;
		for (int i = A; i <= B; i++)
			v1.push_back(ser[i].second);
		if (C < A) {
			for (int i = C; i < A; i++)
				v2.push_back(ser[i].second);
			for (int i = B + 1; i < n; i++)
				v2.push_back(ser[i].second);
		}
		else {
			for (int i = C; i < n; i++)
				v2.push_back(ser[i].second);
		}

		printf("%d %d\n", (int)v1.size(), (int)v2.size());
		for (int i = 0; i < v1.size(); i++)
			printf("%s%d", (i ? " " : ""), v1[i] + 1);
		puts("");
		for (int i = 0; i < v2.size(); i++)
			printf("%s%d", (i ? " " : ""), v2[i] + 1);
		puts("");
	}
	else puts("No");
	return 0;
}


// ~/BAU/ACM-ICPC/Teams/Republic_of_Coders/Corvus
// ~/sudo apt-get verdict Accpeted

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <memory.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
const int N = 300001;
const ll MOD = 1e9 + 7;

int n;
ll x1, x2;
vector<pair<ll,int> > ser;

int main() {
#ifndef ONLINE_JUDGE
	freopen("input.in", "r", stdin);
#endif

	scanf("%d%lld%lld", &n, &x1, &x2);
	for (int i = 0, x; i < n; i++) {
		scanf("%d", &x);
		ser.push_back(make_pair(x, i));
	}

	sort(ser.begin(), ser.end());

	int A = -1, B = -1, C = -1, cnt = -1;
	for (int i = 1; i < n; i++) {
		ll v1 = (x1 + 1ll*i - 1) / (1ll*i);
		ll v2 = (x2 + 1ll*(n - i) - 1) / (1ll*n - i);

		int a = lower_bound(ser.begin(), ser.end(), make_pair(v1,-1)) - ser.begin();
		if (a == ser.size() || n - a < i) continue;
		int b = a + i - 1;
		int c = lower_bound(ser.begin(), ser.end(), make_pair(v2, -1)) - ser.begin();

		if (c == ser.size()) continue;

		if (v2 < v1) {
			if (n - b - 1 + a - c < n - i) continue;
			else {
				A = a, B = b;
				C = c;
				cnt = n - i;
				break;
			}
		}
		else {
			c = max(b+1, c);
			if (n - c < n - i) continue;
			else {
				A = a, B = b;
				C = c;
				cnt = n - i;
				break;
			}
		}
	}

	if (A != -1 && B != -1) {
		puts("Yes");
		vector<int> v1, v2;
		for (int i = A; i <= B; i++)
			v1.push_back(ser[i].second);
		for (int i = 0; i < A; i++)
			v2.push_back(ser[i].second);
		for (int i = B + 1; i < n; i++)
			v2.push_back(ser[i].second);

		printf("%d %d\n", (int)v1.size(), (int)v2.size());
		for (int i = 0; i < v1.size(); i++)
			printf("%s%d", (i ? " " : ""), v1[i] + 1);
		puts("");
		for (int i = 0; i < v2.size(); i++)
			printf("%s%d", (i ? " " : ""), v2[i] + 1);
		puts("");
	}
	else puts("No");
	return 0;
}


// ~/BAU/ACM-ICPC/Teams/Republic_of_Coders/Corvus
// ~/sudo apt-get verdict Accpeted

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <memory.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
const int N = 300001;
const ll MOD = 1e9 + 7;

int n;
ll x1, x2;
vector<pair<ll,int> > ser;

int main() {
#ifndef ONLINE_JUDGE
	freopen("input.in", "r", stdin);
#endif

	scanf("%d%lld%lld", &n, &x1, &x2);
	for (int i = 0, x; i < n; i++) {
		scanf("%d", &x);
		ser.push_back(make_pair(x, i));
	}

	sort(ser.begin(), ser.end());

	int A = -1, B = -1, C = -1;
	for (int i = 1; i < n; i++) {
		ll v1 = (x1 + 1ll*i - 1) / (1ll*i);

		int a = lower_bound(ser.begin(), ser.end(), make_pair(v1, -1)) - ser.begin();
		if (a == ser.size() || n - a < i) continue;
		int b = a + i - 1;

		int l = 1, r = n - i, m, x = -1;
		while (l <= r) {
			m = (l + r) / 2;

			ll v2 = (x2 + 1ll * m - 1) / (1ll * m);
			int c = lower_bound(ser.begin(), ser.end(), make_pair(v2, -1)) - ser.begin();
			int cnt = (v2 < v1 ? n - b - 1 + a - c : n - max(b + 1, c));
			if (c == ser.size() || cnt < m)
				l = m + 1;
			else {
				C = c;
				x = m;
				break;
			}
		}

		if (x != -1) {
			A = a;
			B = b;
			break;
		}
	}

	if (A != -1 && B != -1) {
		puts("Yes");
		vector<int> v1, v2;
		for (int i = A; i <= B; i++)
			v1.push_back(ser[i].second);
		if (C < A) {
			for (int i = C; i < A; i++)
				v2.push_back(ser[i].second);
			for (int i = B + 1; i < n; i++)
				v2.push_back(ser[i].second);
		}
		else {
			for (int i = C; i < n; i++)
				v2.push_back(ser[i].second);
		}

		printf("%d %d\n", (int)v1.size(), (int)v2.size());
		for (int i = 0; i < v1.size(); i++)
			printf("%s%d", (i ? " " : ""), v1[i] + 1);
		puts("");
		for (int i = 0; i < v2.size(); i++)
			printf("%s%d", (i ? " " : ""), v2[i] + 1);
		puts("");
	}
	else puts("No");
	return 0;
}


// ~/BAU/ACM-ICPC/Teams/Republic_of_Coders/Corvus
// ~/sudo apt-get verdict Accpeted

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <memory.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
const int N = 300001;
const ll MOD = 1e9 + 7;

int n;
ll x1, x2;
vector<pair<ll,int> > ser;

int main() {
#ifndef ONLINE_JUDGE
	freopen("input.in", "r", stdin);
#endif

	scanf("%d%lld%lld", &n, &x1, &x2);
	for (int i = 0, x; i < n; i++) {
		scanf("%d", &x);
		ser.push_back(make_pair(x, i));
	}

	sort(ser.begin(), ser.end());

	int A = -1, B = -1, C = -1;
	for (int i = 1; i < n; i++) {
		ll v1 = (x1 + 1ll*i - 1) / (1ll*i);

		int a = lower_bound(ser.begin(), ser.end(), make_pair(v1, -1)) - ser.begin();
		if (a == ser.size() || n - a < i) continue;
		int b = a + i - 1;

		int l = 1, r = n - i, m, x = -1;
		while (l <= r) {
			m = (l + r) / 2;

			ll v2 = (x2 + 1ll * m - 1) / (1ll * m);
			int c = lower_bound(ser.begin(), ser.end(), make_pair(v2, -1)) - ser.begin();
			int cnt = (v2 < v1 ? n - b - 1 + a - c : n - max(b + 1, c));
			if(v2 >= v1) c = max(c, b + 1);

			if (c == ser.size() || cnt < m)
				l = m + 1;
			else {
				if(cnt == m) C = c;
				else {
					cnt = m;
					if (v2 < v1) {
						if (n - b - 1 >= m) C = n - m;
						else {
							cnt -= n - b - 1;
							C = a - cnt;
						}
					}
					else C = n - m;
				}
				x = m;
				break;
			}
		}

		if (x != -1) {
			A = a;
			B = b;
			break;
		}
	}

	if (A != -1 && B != -1) {
		puts("Yes");
		vector<int> v1, v2;
		for (int i = A; i <= B; i++)
			v1.push_back(ser[i].second);
		if (C < A) {
			for (int i = C; i < A; i++)
				v2.push_back(ser[i].second);
			for (int i = B + 1; i < n; i++)
				v2.push_back(ser[i].second);
		}
		else {
			for (int i = C; i < n; i++)
				v2.push_back(ser[i].second);
		}

		printf("%d %d\n", (int)v1.size(), (int)v2.size());
		for (int i = 0; i < v1.size(); i++)
			printf("%s%d", (i ? " " : ""), v1[i] + 1);
		puts("");
		for (int i = 0; i < v2.size(); i++)
			printf("%s%d", (i ? " " : ""), v2[i] + 1);
		puts("");
	}
	else puts("No");
	return 0;
}


// ~/BAU/ACM-ICPC/Teams/Republic_of_Coders/Corvus
// ~/sudo apt-get verdict Accpeted

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <memory.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
const int N = 300001;
const ll MOD = 1e9 + 7;

int n;
ll x1, x2;
vector<pair<ll,int> > ser;

int main() {
#ifndef ONLINE_JUDGE
	freopen("input.in", "r", stdin);
#endif

	scanf("%d%lld%lld", &n, &x1, &x2);
	for (int i = 0, x; i < n; i++) {
		scanf("%d", &x);
		ser.push_back(make_pair(x, i));
	}

	sort(ser.begin(), ser.end());

	int A = -1, B = -1, C = -1;
	for (int i = 1; i < n; i++) {
		ll v1 = (x1 + 1ll*i - 1) / (1ll*i);

		int a = lower_bound(ser.begin(), ser.end(), make_pair(v1, -1)) - ser.begin();
		if (a == ser.size() || n - a < i) continue;
		int b = a + i - 1;

		int l = 1, r = n - i, m, x = -1;
		while (l <= r) {
			m = (l + r) / 2;

			ll v2 = (x2 + 1ll * m - 1) / (1ll * m);
			int c = lower_bound(ser.begin(), ser.end(), make_pair(v2, -1)) - ser.begin();
			int cnt = (v2 < v1 ? n - b - 1 + a - c : n - max(b + 1, c));
			if (v2 < v1 && c == a) c = b + 1;
			if (v2 >= v1) c = max(c, b + 1);

			if (c == ser.size()) cnt = 0;
			if (c == ser.size() || cnt < m) {
				if (m > n - (b - a + 1)) r = m - 1;
				else l = m + 1;
			}
			else {
				if(cnt == m) C = c;
				else {
					cnt = m;
					if (v2 < v1) {
						if (n - b - 1 >= m) C = n - m;
						else {
							cnt -= n - b - 1;
							C = a - cnt;
						}
					}
					else C = n - m;
				}
				x = m;
				break;
			}
		}

		if (x != -1) {
			A = a;
			B = b;
			break;
		}
	}

	if (A != -1 && B != -1) {
		puts("Yes");
		vector<int> v1, v2;
		for (int i = A; i <= B; i++)
			v1.push_back(ser[i].second);
		if (C < A) {
			for (int i = C; i < A; i++)
				v2.push_back(ser[i].second);
			for (int i = B + 1; i < n; i++)
				v2.push_back(ser[i].second);
		}
		else {
			for (int i = C; i < n; i++)
				v2.push_back(ser[i].second);
		}

		printf("%d %d\n", (int)v1.size(), (int)v2.size());
		for (int i = 0; i < v1.size(); i++)
			printf("%s%d", (i ? " " : ""), v1[i] + 1);
		puts("");
		for (int i = 0; i < v2.size(); i++)
			printf("%s%d", (i ? " " : ""), v2[i] + 1);
		puts("");
	}
	else puts("No");
	return 0;
}


#include <iostream>
#include <string>
#include <queue>
#include <stack>
#include <algorithm>
#include <list>
#include <vector>
#include <complex>
#include <utility>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <bitset>
#include <ctime>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <cassert>
#include <cstddef>
#include <iomanip>
#include <numeric>
#include <tuple>
#include <sstream>
#include <fstream>

using namespace std;
#define REP(i, n) for (int (i) = 0; (i) < (n); (i)++)
#define FOR(i, a, b) for (int (i) = (a); (i) < (b); (i)++)
#define RREP(i, a) for(int (i) = (a) - 1; (i) >= 0; (i)--)
#define FORR(i, a, b) for(int (i) = (a) - 1; (i) >= (b); (i)--)
#define DEBUG(C) cerr << #C << " = " << C << endl;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<LL>;
using VVL = vector<VL>;
using VD = vector<double>;
using VVD = vector<VD>;
using PII = pair<int, int>;
using PDD = pair<double, double>;
using PLL = pair<LL, LL>;
using VPII = vector<PII>;
template<typename T> using VT = vector<T>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) rbegin((a)), rend((a))
#define SORT(a) sort(ALL((a)))
#define RSORT(a) sort(RALL((a)))
#define REVERSE(a) reverse(ALL((a)))
#define MP make_pair
#define FORE(a, b) for (auto &&a : (b))
#define FIND(s, e) ((s).find(e) != (s).end())
#define EB emplace_back
template<typename T> inline bool chmax(T &a, T b){if (a < b){a = b;return true;}return false;}
template<typename T> inline bool chmin(T &a, T b){if (a > b){a = b;return true;}return false;}

const int INF = 1e9;
const int MOD = INF + 7;
const LL LLINF = 1e18;

const int MAX = 3e5 + 10;
int n;
LL x[2];
pair<LL, int> c[MAX];

int main(void) {
    scanf("%d%lld%lld", &n, x, x + 1);
    REP(i, n) {
        scanf("%lld", &c[i].first);
        c[i].second = i;
    }
    sort(c, c + n);
    REP(_, 2) {
        const auto f = x[_];
        const auto s = x[(_ + 1) % 2];
        LL f_mi = c[0].first, s_mi = LLINF;
        REP(i, n - 1) {
            s_mi = c[i + 1].first;
            const double f_a_res = 1. * f / (i + 1);
            const double s_a_res = 1. * s / (n - i - 1);
            if (f_mi >= f_a_res && s_mi >= s_a_res) {
                puts("Yes");
                if (_ == 0) {
                    printf("%d %d\n", i + 1, n - i - 1);
                    REP(j, i + 1) printf("%d%c", c[j].second + 1, (j + 1 == i + 1 ? '\n' : ' '));
                    REP(j, n - i - 1) printf("%d%c", c[i + 1 + j].second + 1, (j + 1 == n - i - 1 ? '\n' : ' '));
                } else {
                    printf("%d %d\n", n - i - 1, i + 1);
                    REP(j, n - i - 1) printf("%d%c", c[i + 1 + j].second + 1, (j + 1 == n - i - 1 ? '\n' : ' '));
                    REP(j, i + 1) printf("%d%c", c[j].second + 1, (j + 1 == i + 1 ? '\n' : ' '));
                }
                return 0;
            }
        }
    }
    reverse(c, c + n);
    REP(_, 2) {
        const auto f = x[_];
        const auto s = x[(_ + 1) % 2];
        LL f_mi = LLINF, s_mi = c[n - 1].first;
        REP(i, n - 1) {
            f_mi = c[i].first;
            const double f_a_res = 1. * f / (i + 1);
            const double s_a_res = 1. * s / (n - i - 1);
            if (f_mi >= f_a_res && s_mi >= s_a_res) {
                puts("Yes");
                if (_ == 0) {
                    printf("%d %d\n", i + 1, n - i - 1);
                    REP(j, i + 1) printf("%d%c", c[j].second + 1, (j + 1 == i + 1 ? '\n' : ' '));
                    REP(j, n - i - 1) printf("%d%c", c[i + 1 + j].second + 1, (j + 1 == n - i - 1 ? '\n' : ' '));
                } else {
                    printf("%d %d\n", n - i - 1, i + 1);
                    REP(j, n - i - 1) printf("%d%c", c[i + 1 + j].second + 1, (j + 1 == n - i - 1 ? '\n' : ' '));
                    REP(j, i + 1) printf("%d%c", c[j].second + 1, (j + 1 == i + 1 ? '\n' : ' '));
                }
                return 0;
            }
        }
    }
    cout << "No" << endl;
}


#include <iostream>
#include <string>
#include <queue>
#include <stack>
#include <algorithm>
#include <list>
#include <vector>
#include <complex>
#include <utility>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <bitset>
#include <ctime>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <cassert>
#include <cstddef>
#include <iomanip>
#include <numeric>
#include <tuple>
#include <sstream>
#include <fstream>

using namespace std;
#define REP(i, n) for (int (i) = 0; (i) < (n); (i)++)
#define FOR(i, a, b) for (int (i) = (a); (i) < (b); (i)++)
#define RREP(i, a) for(int (i) = (a) - 1; (i) >= 0; (i)--)
#define FORR(i, a, b) for(int (i) = (a) - 1; (i) >= (b); (i)--)
#define DEBUG(C) cerr << #C << " = " << C << endl;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<LL>;
using VVL = vector<VL>;
using VD = vector<double>;
using VVD = vector<VD>;
using PII = pair<int, int>;
using PDD = pair<double, double>;
using PLL = pair<LL, LL>;
using VPII = vector<PII>;
template<typename T> using VT = vector<T>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) rbegin((a)), rend((a))
#define SORT(a) sort(ALL((a)))
#define RSORT(a) sort(RALL((a)))
#define REVERSE(a) reverse(ALL((a)))
#define MP make_pair
#define FORE(a, b) for (auto &&a : (b))
#define FIND(s, e) ((s).find(e) != (s).end())
#define EB emplace_back
template<typename T> inline bool chmax(T &a, T b){if (a < b){a = b;return true;}return false;}
template<typename T> inline bool chmin(T &a, T b){if (a > b){a = b;return true;}return false;}

const int INF = 1e9;
const int MOD = INF + 7;
const LL LLINF = 1e18;

const int MAX = 3e5 + 10;
int n;
LL x[2];
pair<LL, int> c[MAX];

int main(void) {
    scanf("%d%lld%lld", &n, x, x + 1);
    REP(i, n) {
        scanf("%lld", &c[i].first);
        c[i].second = i;
    }
    sort(c, c + n);
    REP(_, 2) {
        const auto f = x[_];
        const auto s = x[(_ + 1) % 2];
        LL f_mi = c[0].first, s_mi = LLINF;
        REP(i, n - 1) {
            s_mi = c[i + 1].first;
            const double f_a_res = 1. * f / (i + 1);
            const double s_a_res = 1. * s / (n - i - 1);
            if (f_mi >= f_a_res && s_mi >= s_a_res) {
                puts("Yes");
                if (_ == 0) {
                    printf("%d %d\n", i + 1, n - i - 1);
                    REP(j, i + 1) printf("%d%c", c[j].second + 1, (j + 1 == i + 1 ? '\n' : ' '));
                    REP(j, n - i - 1) printf("%d%c", c[i + 1 + j].second + 1, (j + 1 == n - i - 1 ? '\n' : ' '));
                } else {
                    printf("%d %d\n", n - i - 1, i + 1);
                    REP(j, n - i - 1) printf("%d%c", c[i + 1 + j].second + 1, (j + 1 == n - i - 1 ? '\n' : ' '));
                    REP(j, i + 1) printf("%d%c", c[j].second + 1, (j + 1 == i + 1 ? '\n' : ' '));
                }
                return 0;
            }
        }
    }
    cout << "No" << endl;
}


#include <iostream>
#include <string>
#include <queue>
#include <stack>
#include <algorithm>
#include <list>
#include <vector>
#include <complex>
#include <utility>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <bitset>
#include <ctime>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <cassert>
#include <cstddef>
#include <iomanip>
#include <numeric>
#include <tuple>
#include <sstream>
#include <fstream>

using namespace std;
#define REP(i, n) for (int (i) = 0; (i) < (n); (i)++)
#define FOR(i, a, b) for (int (i) = (a); (i) < (b); (i)++)
#define RREP(i, a) for(int (i) = (a) - 1; (i) >= 0; (i)--)
#define FORR(i, a, b) for(int (i) = (a) - 1; (i) >= (b); (i)--)
#define DEBUG(C) cerr << #C << " = " << (C) << endl;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<LL>;
using VVL = vector<VL>;
using VD = vector<double>;
using VVD = vector<VD>;
using PII = pair<int, int>;
using PDD = pair<double, double>;
using PLL = pair<LL, LL>;
using VPII = vector<PII>;
template<typename T> using VT = vector<T>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) rbegin((a)), rend((a))
#define SORT(a) sort(ALL((a)))
#define RSORT(a) sort(RALL((a)))
#define REVERSE(a) reverse(ALL((a)))
#define MP make_pair
#define FORE(a, b) for (auto &&a : (b))
#define FIND(s, e) ((s).find(e) != (s).end())
#define EB emplace_back
template<typename T> inline bool chmax(T &a, T b){if (a < b){a = b;return true;}return false;}
template<typename T> inline bool chmin(T &a, T b){if (a > b){a = b;return true;}return false;}

const int INF = 1e9;
const int MOD = INF + 7;
const LL LLINF = 1e18;

const int MAX = 3e5 + 10;
int n;
LL x[2];
pair<LL, int> c[MAX];

int main(void) {
    scanf("%d%lld%lld", &n, x, x + 1);
    REP(i, n) {
        scanf("%lld", &c[i].first);
        c[i].second = i;
    }
    sort(c, c + n);
    REP(_, 2) {
        const auto f = x[_];
        const auto s = x[(_ + 1) % 2];
        REP(i, n) {
            // i-1以下使わない
            int low = i - 1, high = n - 1;
            while (high - low > 1) {
                const int mid = low + (high - low) / 2;
                if (1. * f / (mid - i + 1) <= c[i].first) {
                    high = mid;
                } else {
                    low = mid;
                }
            }
            // if (_ && i == 0) {
            //     DEBUG(high)
            //     DEBUG(high-i+1)
            //     DEBUG(n-high-1)
            //     DEBUG((high-i) + (n-high))
            //
            // }
            if (high < n - 1 && 1. * f / (high - i + 1) <= c[i].first && 1. * s / (n - high - 1) <= c[high + 1].first) {
                puts("Yes");
                if (_ == 0) {
                    printf("%d %d\n", high - i + 1, n - high - 1);
                    FOR(j, i, high + 1) printf("%d%c", c[j].second + 1, (j == high ? '\n' : ' '));
                    FOR(j, high + 1, n) printf("%d%c", c[j].second + 1, (j + 1 == n ? '\n' : ' '));
                } else {
                    printf("%d %d\n", n - high - 1, high - i + 1);
                    FOR(j, high + 1, n) printf("%d%c", c[j].second + 1, (j + 1 == n ? '\n' : ' '));
                    FOR(j, i, high + 1) printf("%d%c", c[j].second + 1, (j == high ? '\n' : ' '));
                }
                return 0;
            }
        }
    }
    cout << "No" << endl;
}


#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;

int n,x1,x2,c[300005],p;
bool b[300005],bb[300005],f,g,ss;

struct item
{
	int d,pos;
	inline bool operator < (const item &t) const
	{
		return d>t.d;
	}
}t[300005];

int main()
{
	scanf("%d%d%d",&n,&x1,&x2);
	for(int i=1;i<=n;i++)
		scanf("%d",&t[i].d),t[i].pos=i;
	sort(t+1,t+n+1);
	for(int i=1;i<=n;i++)
		c[i]=t[i].d;
	for(int i=1;i<=n;i++)
		if(1.0*x2/i<=c[i])
			g|=b[i]=true;
	for(int i=1;i<=n;i++)
		bb[i]=bb[i-1]|b[i];
	if(!g)
	{
		puts("No");
		return 0;
	}
	f=false;
	for(int i=1,j=1;i<=n;i++)
	{
		while(j<=n&&c[j]>=1.0*x1/i)
			j++;
		if(j>i&&bb[j-i-1])
		{
			puts("Yes");
			int k=j-i-1;
			while(!b[k])
				--k;
			printf("%d %d\n",i,k);
			for(k=j-i;k<j;k++)
				printf("%d ",t[k].pos);
			puts("");
			k=j-i-1;
			while(!b[k])
				--k;
			while(k)
				printf("%d ",t[k].pos),k--;
			return 0;
		}
	}
	g=false;
	memset(b,false,sizeof(b));
	for(int i=1;i<=n;i++)
		if(1.0*x1/i<=c[i])
			g|=b[i]=true;
	for(int i=1;i<=n;i++)
		bb[i]=bb[i-1]|b[i];
	if(!g)
	{
		puts("No");
		return 0;
	}
	for(int i=1,j=1;i<=n;i++)
	{
		while(j<=n&&c[j]>=1.0*x2/i)
			j++;
		if(j>i&&bb[j-i-1])
		{
			puts("Yes");
			int k=j-i-1;
			while(!b[k])
				--k;
			printf("%d %d\n",k,i);
			while(k)
				printf("%d ",t[k].pos),k--;
			puts("");
			for(k=j-i;k<j;k++)
				printf("%d ",t[k].pos);
			return 0;
		}
	}
	puts("No");
	return 0;
}


#include<cstdio>
#include<algorithm>
using namespace std;

int n,x1,x2,c[300005],p;
bool b[300005],bb[300005],f,g,ss;

struct item
{
	int d,pos;
	inline bool operator < (const item &t) const
	{
		return d>t.d;
	}
}t[300005];

int main()
{
	scanf("%d%d%d",&n,&x1,&x2);
	for(int i=1;i<=n;i++)
		scanf("%d",&t[i].d),t[i].pos=i;
	sort(t+1,t+n+1);
	for(int i=1;i<=n;i++)
		c[i]=t[i].d;
	for(int i=1;i<=n;i++)
		if(1.0*x2/i<=c[i])
			g|=b[i]=true;
	for(int i=1;i<=n;i++)
		bb[i]=bb[i-1]|b[i];
	if(!g)
	{
		puts("No");
		return 0;
	}
	f=false;
	for(int i=1,j=1;i<=n;i++)
	{
		while(j<=n&&c[j]>1.0*x1/i)
			j++;
		if(j>i&&bb[j-i-1])
		{
			puts("Yes");
			int k=j-i-1;
			while(!b[k])
				--k;
			printf("%d %d\n",i,k);
			for(k=j-i;k<j;k++)
				printf("%d ",t[k].pos);
			puts("");
			k=j-i-1;
			while(!b[k])
				--k;
			while(k)
				printf("%d ",t[k].pos),k--;
			return 0;
		}
	}
	g=false;
	for(int i=1;i<=n;i++)
		if(1.0*x1/i<=c[i])
			g|=b[i]=true;
	for(int i=1;i<=n;i++)
		bb[i]=bb[i-1]|b[i];
	if(!g)
	{
		puts("No");
		return 0;
	}
	for(int i=1,j=1;i<=n;i++)
	{
		while(j<=n&&c[j]>1.0*x2/i)
			j++;
		if(j>i&&bb[j-i-1])
		{
			puts("Yes");
			int k=j-i-1;
			while(!b[k])
				--k;
			printf("%d %d\n",k,i);
			while(k)
				printf("%d ",t[k].pos),k--;
			puts("");
			for(k=j-i;k<j;k++)
				printf("%d ",t[k].pos);
			return 0;
		}
	}
	puts("No");
	return 0;
}


#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;

int n,x1,x2,c[300005],p;
bool b[300005],bb[300005],f,g,ss;

struct item
{
	int d,pos;
	inline bool operator < (const item &t) const
	{
		return d>t.d;
	}
}t[300005];

int main()
{
	scanf("%d%d%d",&n,&x1,&x2);
	for(int i=1;i<=n;i++)
		scanf("%d",&t[i].d),t[i].pos=i;
	sort(t+1,t+n+1);
	for(int i=1;i<=n;i++)
		c[i]=t[i].d;
	for(int i=1;i<=n;i++)
		if(1.0*x2/i<=c[i])
			g|=b[i]=true;
	for(int i=1;i<=n;i++)
		bb[i]=bb[i-1]|b[i];
	if(!g)
	{
		puts("No");
		return 0;
	}
	f=false;
	for(int i=1,j=1;i<=n;i++)
	{
		while(j<=n&&c[j]>1.0*x1/i)
			j++;
		if(j>i&&bb[j-i-1])
		{
			puts("Yes");
			int k=j-i-1;
			while(!b[k])
				--k;
			printf("%d %d\n",i,k);
			for(k=j-i;k<j;k++)
				printf("%d ",t[k].pos);
			puts("");
			k=j-i-1;
			while(!b[k])
				--k;
			while(k)
				printf("%d ",t[k].pos),k--;
			return 0;
		}
	}
	g=false;
	memset(b,false,sizeof(b));
	for(int i=1;i<=n;i++)
		if(1.0*x1/i<=c[i])
			g|=b[i]=true;
	for(int i=1;i<=n;i++)
		bb[i]=bb[i-1]|b[i];
	if(!g)
	{
		puts("No");
		return 0;
	}
	for(int i=1,j=1;i<=n;i++)
	{
		while(j<=n&&c[j]>1.0*x2/i)
			j++;
		if(j>i&&bb[j-i-1])
		{
			puts("Yes");
			int k=j-i-1;
			while(!b[k])
				--k;
			printf("%d %d\n",k,i);
			while(k)
				printf("%d ",t[k].pos),k--;
			puts("");
			for(k=j-i;k<j;k++)
				printf("%d ",t[k].pos);
			return 0;
		}
	}
	puts("No");
	return 0;
}


#include <iostream>
#include <fstream>
#include <iomanip>
#include <climits>
#include <limits>
#include <algorithm>
#include <vector>
#include <deque>
#include <queue>
#include <list>
#include <stack>
#include <string>
#include <functional>
#include <numeric>
#include <map>
#include <set>
#include <cstdlib>
#include <bitset>
#include <unordered_map>
#include <random>
#include <cmath>
#include <complex>

using namespace std;

typedef long long int ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;

const int INFL = (int)1e9;
const ll INFLL = (ll)1e18;
const double INFD = numeric_limits<double>::infinity();
const double PI = 3.14159265358979323846;
#define Loop(i, n) for(int i = 0; i < (int)n; i++)
#define Loopll(i, n) for(ll i = 0; i < (ll)n; i++)
#define Loop1(i, n) for(int i = 1; i <= (int)n; i++)
#define Loopll1(i, n) for(ll i = 1; i <= (ll)n; i++)
#define Loopr(i, n) for(int i = (int)n - 1; i >= 0; i--)
#define Looprll(i, n) for(ll i = (ll)n - 1; i >= 0; i--)
#define Loopr1(i, n) for(int i = (int)n; i >= 1; i--)
#define Looprll1(i, n) for(ll i = (ll)n; i >= 1; i--)
#define Loopitr(itr, container) for(auto itr = container.begin(); itr != container.end(); itr++)
#define printv(vector) Loop(i, vector.size()) { cout << vector[i] << " "; } cout << endl;
#define printmx(matrix) Loop(i, matrix.size()) { Loop(j, matrix[i].size()) { cout << matrix[i][j] << " "; } cout << endl; }
#define rnd(d) (ll)((double)(d) + (d >= 0 ? 0.5 : -0.5))
#define floorsqrt(x) ((ll)sqrt((double)x) + ((ll)sqrt((double)x) * (ll)sqrt((double)x) <= (ll)(x) ? 0 : -1))
#define ceilsqrt(x) ((ll)sqrt((double)x) + ((ll)x <= (ll)sqrt((double)x) * (ll)sqrt((double)x) ? 0 : 1))
#define ceildiv(a, b) ((ll)(a) / (ll)(b) + ((ll)(a) % (ll)(b) == 0 ? 0 : 1))
#define bitmanip(m,val) static_cast<bitset<(int)m>>(val)

/*******************************************************/

int main() {
	int n; cin >> n;
	vll x(2); cin >> x[0] >> x[1];
	vector<pair<ll, int>> c(n); Loop(i, n) {
		cin >> c[i].first;
		c[i].second = i + 1;
	}
	sort(c.begin(), c.end(), greater<pair<ll, int>>());
	Loop(k, 2) {
		int index = n;
		Loop(i, n) {
			if ((i + 1) * c[i].first >= x[k % 2]) {
				index = i;
				break;
			}
		}
		int index2 = n;
		for (int i = index + 1; i < n; i++) {
			if ((i - index) * c[i].first >= x[(k + 1) % 2]) {
				index2 = i;
				break;
			}
		}
		if (index2 != n) {
			cout << "Yes" << endl;
			if (k == 0) {
				cout << index << " " << index2 - index << endl;
				Loop(i, index + 1) {
					cout << c[i].second << " ";
				}
				cout << endl;
				for (int i = index + 1; i <= index2; i++) {
					cout << c[i].second << " ";
				}
				cout << endl;
			}
			else {
				cout << index2 - index << " " << index + 1 << endl;
				for (int i = index + 1; i <= index2; i++) {
					cout << c[i].second << " ";
				}
				cout << endl;
				Loop(i, index + 1) {
					cout << c[i].second << " ";
				}
				cout << endl;
			}
			return 0;
		}
	}
	cout << "No" << endl;
}


#include <iostream>
#include <fstream>
#include <iomanip>
#include <climits>
#include <limits>
#include <algorithm>
#include <vector>
#include <deque>
#include <queue>
#include <list>
#include <stack>
#include <string>
#include <functional>
#include <numeric>
#include <map>
#include <set>
#include <cstdlib>
#include <bitset>
#include <unordered_map>
#include <random>
#include <cmath>
#include <complex>

using namespace std;

typedef long long int ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;

const int INFL = (int)1e9;
const ll INFLL = (ll)1e18;
const double INFD = numeric_limits<double>::infinity();
const double PI = 3.14159265358979323846;
#define Loop(i, n) for(int i = 0; i < (int)n; i++)
#define Loopll(i, n) for(ll i = 0; i < (ll)n; i++)
#define Loop1(i, n) for(int i = 1; i <= (int)n; i++)
#define Loopll1(i, n) for(ll i = 1; i <= (ll)n; i++)
#define Loopr(i, n) for(int i = (int)n - 1; i >= 0; i--)
#define Looprll(i, n) for(ll i = (ll)n - 1; i >= 0; i--)
#define Loopr1(i, n) for(int i = (int)n; i >= 1; i--)
#define Looprll1(i, n) for(ll i = (ll)n; i >= 1; i--)
#define Loopitr(itr, container) for(auto itr = container.begin(); itr != container.end(); itr++)
#define printv(vector) Loop(i, vector.size()) { cout << vector[i] << " "; } cout << endl;
#define printmx(matrix) Loop(i, matrix.size()) { Loop(j, matrix[i].size()) { cout << matrix[i][j] << " "; } cout << endl; }
#define rnd(d) (ll)((double)(d) + (d >= 0 ? 0.5 : -0.5))
#define floorsqrt(x) ((ll)sqrt((double)x) + ((ll)sqrt((double)x) * (ll)sqrt((double)x) <= (ll)(x) ? 0 : -1))
#define ceilsqrt(x) ((ll)sqrt((double)x) + ((ll)x <= (ll)sqrt((double)x) * (ll)sqrt((double)x) ? 0 : 1))
#define ceildiv(a, b) ((ll)(a) / (ll)(b) + ((ll)(a) % (ll)(b) == 0 ? 0 : 1))
#define bitmanip(m,val) static_cast<bitset<(int)m>>(val)

/*******************************************************/

int main() {
	int n; cin >> n;
	vll x(2); cin >> x[0] >> x[1];
	vector<pair<ll, int>> c(n); Loop(i, n) {
		cin >> c[i].first;
		c[i].second = i + 1;
	}
	sort(c.begin(), c.end(), greater<pair<ll, int>>());
	Loop(k, 2) {
		int index = n;
		Loop(i, n) {
			if ((i + 1) * c[i].first >= x[k % 2]) {
				index = i;
				break;
			}
		}
		int index2 = n;
		for (int i = index + 1; i < n; i++) {
			if ((i - index) * c[i].first >= x[(k + 1) % 2]) {
				index2 = i;
				break;
			}
		}
		if (index2 != n) {
			cout << "YES" << endl;
			if (k == 0) {
				cout << index << " " << index2 - index << endl;
				Loop(i, index + 1) {
					cout << c[i].second << " ";
				}
				cout << endl;
				for (int i = index + 1; i <= index2; i++) {
					cout << c[i].second << " ";
				}
				cout << endl;
			}
			else {
				cout << index2 - index << " " << index + 1 << endl;
				for (int i = index + 1; i <= index2; i++) {
					cout << c[i].second << " ";
				}
				cout << endl;
				Loop(i, index + 1) {
					cout << c[i].second << " ";
				}
				cout << endl;
			}
			return 0;
		}
	}
	cout << "No" << endl;
}


#include <iostream>
#include <fstream>
#include <iomanip>
#include <climits>
#include <limits>
#include <algorithm>
#include <vector>
#include <deque>
#include <queue>
#include <list>
#include <stack>
#include <string>
#include <functional>
#include <numeric>
#include <map>
#include <set>
#include <cstdlib>
#include <bitset>
#include <unordered_map>
#include <random>
#include <cmath>
#include <complex>

using namespace std;

typedef long long int ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;

const int INFL = (int)1e9;
const ll INFLL = (ll)1e18;
const double INFD = numeric_limits<double>::infinity();
const double PI = 3.14159265358979323846;
#define Loop(i, n) for(int i = 0; i < (int)n; i++)
#define Loopll(i, n) for(ll i = 0; i < (ll)n; i++)
#define Loop1(i, n) for(int i = 1; i <= (int)n; i++)
#define Loopll1(i, n) for(ll i = 1; i <= (ll)n; i++)
#define Loopr(i, n) for(int i = (int)n - 1; i >= 0; i--)
#define Looprll(i, n) for(ll i = (ll)n - 1; i >= 0; i--)
#define Loopr1(i, n) for(int i = (int)n; i >= 1; i--)
#define Looprll1(i, n) for(ll i = (ll)n; i >= 1; i--)
#define Loopitr(itr, container) for(auto itr = container.begin(); itr != container.end(); itr++)
#define printv(vector) Loop(i, vector.size()) { cout << vector[i] << " "; } cout << endl;
#define printmx(matrix) Loop(i, matrix.size()) { Loop(j, matrix[i].size()) { cout << matrix[i][j] << " "; } cout << endl; }
#define rnd(d) (ll)((double)(d) + (d >= 0 ? 0.5 : -0.5))
#define floorsqrt(x) ((ll)sqrt((double)x) + ((ll)sqrt((double)x) * (ll)sqrt((double)x) <= (ll)(x) ? 0 : -1))
#define ceilsqrt(x) ((ll)sqrt((double)x) + ((ll)x <= (ll)sqrt((double)x) * (ll)sqrt((double)x) ? 0 : 1))
#define ceildiv(a, b) ((ll)(a) / (ll)(b) + ((ll)(a) % (ll)(b) == 0 ? 0 : 1))
#define bitmanip(m,val) static_cast<bitset<(int)m>>(val)

/*******************************************************/

int main() {
	int n; cin >> n;
	vll x(2); cin >> x[0] >> x[1];
	vector<pair<ll, int>> c(n); Loop(i, n) {
		cin >> c[i].first;
		c[i].second = i + 1;
	}
	sort(c.begin(), c.end(), greater<pair<ll, int>>());
	Loop(k, 2) {
		int index = n;
		Loop(i, n) {
			if ((i + 1) * c[i].first >= x[k % 2]) {
				index = i;
				break;
			}
		}
		int index2 = n;
		for (int i = index + 1; i < n; i++) {
			if ((i - index) * c[i].first >= x[(k + 1) % 2]) {
				index2 = i;
				break;
			}
		}
		if (index2 != n) {
			cout << "Yes" << endl;
			if (k == 0) {
				cout << index + 1 << " " << index2 - index << endl;
				Loop(i, index + 1) {
					cout << c[i].second << " ";
				}
				cout << endl;
				for (int i = index + 1; i <= index2; i++) {
					cout << c[i].second << " ";
				}
				cout << endl;
			}
			else {
				cout << index2 - index << " " << index + 1 << endl;
				for (int i = index + 1; i <= index2; i++) {
					cout << c[i].second << " ";
				}
				cout << endl;
				Loop(i, index + 1) {
					cout << c[i].second << " ";
				}
				cout << endl;
			}
			return 0;
		}
	}
	cout << "No" << endl;
}


#include<bits/stdc++.h>
using namespace std;

int main()
{
    vector<int> load_balancing[2];
    vector<pair<int,int>> servers;

    int n,x1,x2;

    cin >> n >> x1 >> x2;

    for(int i=1;i<=n;i++)
    {
        int c;
        cin >> c;
        servers.push_back(make_pair(c,i));
    }

    sort(servers.begin(),servers.end());

    //cout << "****" << endl;
    //for(auto c : servers) //cout << c.first << " ";
    //cout << endl;

    bool flag = false;

    int last = n;

    for(int i=1;i<n;i++)
    {
        int cost_margin = ceil((x1*1.0)/i);
        int index = lower_bound(servers.begin(),servers.end(),make_pair(cost_margin,-1)) - servers.begin();

        //cout << "At i = " << i << endl;
        //cout << "index = " << index << endl;
        //cout << "Cost Margin = " << cost_margin << endl;

        if(index>=0 && index<n-i)
        {
            if(index+i<n)
            {
                for(int k=index+i;k<last;k++)
                {
                    int p = ceil((x2*1.0)/servers[k].first);
                    //cout << "k = " << k << endl;
                    //cout << "p = " << p << endl;
                    if(index+i+p-1<n)
                    {
                        for(int j=0;j<i;j++)
                        {
                            load_balancing[0].push_back(servers[index+j].second);
                        }
                        for(int j=0;j<p;j++)
                        {
                            load_balancing[1].push_back(servers[k+j].second);
                        }

                        flag = true;

                        break;
                    }
                }

                if(flag) break;

                last = index+i;
                //cout << "last  = " << last << endl;
            }

        }

    }

    if(!flag) cout << "No" << endl;
    else
    {
        cout << "Yes" << endl;
        cout << load_balancing[0].size() << " " << load_balancing[1].size() << endl;

        for(int c : load_balancing[0]) cout << c << " ";
        cout << endl;
        for(int c : load_balancing[1]) cout << c << " ";
        cout << endl;
    }

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

int main()
{
    vector<int> load_balancing[2];
    vector<pair<int,int>> servers;

    int n,x1,x2;

    cin >> n >> x1 >> x2;

    for(int i=1;i<=n;i++)
    {
        int c;
        cin >> c;
        servers.push_back(make_pair(c,i));
    }

    sort(servers.begin(),servers.end());

    //cout << "****" << endl;
    //for(auto c : servers) //cout << c.first << " ";
    //cout << endl;

    bool flag = false;

    int last = n;

    for(int i=1;i<n;i++)
    {
        int cost_margin = ceil((x1*1.0)/i);
        int index = lower_bound(servers.begin(),servers.end(),make_pair(cost_margin,-1)) - servers.begin();

        //cout << "At i = " << i << endl;
        //cout << "index = " << index << endl;
        //cout << "Cost Margin = " << cost_margin << endl;

        if(index>=0 && index<n-i)
        {
            if(index+i<n)
            {
                for(int k=index+i;k<last;k++)
                {
                    int p = ceil((x2*1.0)/servers[k].first);
                    //cout << "k = " << k << endl;
                    //cout << "p = " << p << endl;
                    if(index+i+p-1<n)
                    {
                        for(int j=0;j<i;j++)
                        {
                            load_balancing[0].push_back(servers[index+j].second);
                        }
                        for(int j=0;j<p;j++)
                        {
                            load_balancing[1].push_back(servers[k+j].second);
                        }

                        flag = true;

                        break;
                    }
                }

                if(flag) break;

                last = index+i;
                //cout << "last  = " << last << endl;
            }

        }

    }

    if(!flag) cout << "No" << endl;
    else
    {
        cout << "Yes" << endl;
        cout << load_balancing[0].size() << " " << load_balancing[1].size() << endl;

        for(int c : load_balancing[0]) //cout << c << " ";
        cout << endl;
        for(int c : load_balancing[1]) //cout << c << " ";
        cout << endl;
    }

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

int main()
{
    vector<int> load_balancing[2];
    vector<pair<int,int>> servers;

    int n,x1,x2;

    cin >> n >> x1 >> x2;

    for(int i=1;i<=n;i++)
    {
        int c;
        cin >> c;
        servers.push_back(make_pair(c,i));
    }

    sort(servers.begin(),servers.end());

    //cout << "****" << endl;
    for(auto c : servers) //cout << c.first << " ";
    //cout << endl;

    bool flag = false;

    int last = n;

    for(int i=1;i<n;i++)
    {
        int cost_margin = ceil((x1*1.0)/i);
        int index = lower_bound(servers.begin(),servers.end(),make_pair(cost_margin,-1)) - servers.begin();

        //cout << "At i = " << i << endl;
        //cout << "index = " << index << endl;
        //cout << "Cost Margin = " << cost_margin << endl;

        if(index>=0 && index<n-i)
        {
            if(index+i<n)
            {
                for(int k=index+i;k<last;k++)
                {
                    int p = ceil((x2*1.0)/servers[k].first);
                    //cout << "k = " << k << endl;
                    //cout << "p = " << p << endl;
                    if(index+i+p-1<n)
                    {
                        for(int j=0;j<i;j++)
                        {
                            load_balancing[0].push_back(servers[index+j].second);
                        }
                        for(int j=0;j<p;j++)
                        {
                            load_balancing[1].push_back(servers[k+j].second);
                        }

                        flag = true;

                        break;
                    }
                }

                if(flag) break;

                last = index+i;
                //cout << "last  = " << last << endl;
            }

        }

    }

    if(!flag) cout << "No" << endl;
    else
    {
        cout << "Yes" << endl;
        cout << load_balancing[0].size() << " " << load_balancing[1].size() << endl;

        for(int c : load_balancing[0]) //cout << c << " ";
        cout << endl;
        for(int c : load_balancing[1]) //cout << c << " ";
        cout << endl;
    }

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

bool f(int n,int x1,int x2,vector<pair<int,int>> &servers,vector<int> load_balancing[])
{
//    cout << "****" << endl;
//    for(auto c : servers) cout << c.first << " ";
//    cout << endl;

    bool flag = false;

    int last = n;

    for(int i=1;i<n;i++)
    {
        int cost_margin = ceil((x1*1.0)/i);
        int index = lower_bound(servers.begin(),servers.end(),make_pair(cost_margin,-1)) - servers.begin();

//        cout << "At i = " << i << endl;
//        cout << "index = " << index << endl;
//        cout << "Cost Margin = " << cost_margin << endl;

        if(index>=0 && index<n-i)
        {
            if(index+i<n)
            {
                for(int k=index+i;k<last;k++)
                {
                    int p = ceil((x2*1.0)/servers[k].first);
//                    cout << "k = " << k << endl;
//                    cout << "p = " << p << endl;
                    if(k+p-1<n)
                    {
                        for(int j=0;j<i;j++)
                        {
                            load_balancing[0].push_back(servers[index+j].second);
                        }
                        for(int j=0;j<p;j++)
                        {
                            load_balancing[1].push_back(servers[k+j].second);
                    //        cout << servers[k+j].second <<  " ";
                        }
                      //  cout << endl;

                        flag = true;

                        break;
                    }
                }

                if(flag) break;

                last = index+i;
                //cout << "last  = " << last << endl;
            }

        }

    }

    return flag;

}

int main()
{
    bool flag = false;
    vector<int> load_balancing[2];
    vector<pair<int,int>> servers;

    int n,x1,x2;

    cin >> n >> x1 >> x2;

    for(int i=1;i<=n;i++)
    {
        int c;
        cin >> c;
        servers.push_back(make_pair(c,i));
    }

    sort(servers.begin(),servers.end());

    bool flag1 = f(n,x1,x2,servers,load_balancing);
    if(!flag1)
    {
        flag = f(n,x2,x1,servers,load_balancing);

        if(!flag) cout << "No" << endl;
        else
        {
            cout << "Yes" << endl;
            cout << load_balancing[1].size() << " " << load_balancing[0].size() << endl;

            for(int c : load_balancing[1]) cout << c << " ";
            cout << endl;
            for(int c : load_balancing[0]) cout << c << " ";
            cout << endl;
        }
    }
    else
    {
        cout << "Yes" << endl;
        cout << load_balancing[0].size() << " " << load_balancing[1].size() << endl;

        for(int c : load_balancing[0]) cout << c << " ";
        cout << endl;
        for(int c : load_balancing[1]) cout << c << " ";
        cout << endl;
    }

    return 0;
}


#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <set>
#include <map>
#include <string>
#include <queue>
#include <stack>
#include <cstring>
#include <iterator>
#include <cmath>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <chrono>

#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")

using namespace std;
typedef long long mt;

template<typename T>
constexpr mt infValue = std::is_same<T, int>::value ? 2000100007 : 8600000000000000007ll;
template<typename T>
constexpr mt maxValue = std::is_same<T, int>::value ? 1000000007 : 1000000000000000001ll;

#define rep(a, b, i) for(register mt i = a; i < b; ++i)
#define repe(a, b, i) for(register mt i = a; i <= b; ++i)
#define repd(a, b, i) for(register mt i = a; i > b; --i)
#define repde(a, b, i) for(register mt i = a; i >= b; --i)

const mt INF = infValue<mt>;
const long long MOD = 1000000007ll;
const double EPS = 1e-6;
const mt MAX = maxValue<mt>;

#define N 300011
#define K 5001
#define P 18
#define M (2000111)

mt n, x1, x2;
pair<mt, mt> c[N];
bool sw, ok;
mt trm[N], m[N], lx;

vector<mt> answ1, answ2;

int main(void)
{
#ifdef _DEBUG
	freopen("in.txt", "r", stdin);
#endif
	scanf("%lld %lld %lld", &n, &x1, &x2);
	if (x1 < x2) swap(x1, x2), sw = true;
	rep(0, n, i)
		scanf("%lld\n", &c[i].first), c[i].second = i + 1;
	sort(c, c + n), trm[n] = n - 1, lx = INF;
	repde(n - 1, 0, i) {
		mt x = (c[i].first - 1 + x2) / c[i].first;
		mt nc = n - i;
		m[i] = x - nc;
		trm[i] = trm[i + 1];
		if (m[trm[i]] > m[i])
			trm[i] = i;
	}
	rep(0, n, i) {
		if(i) lx = min(lx, m[i - 1]);
		mt x = (c[i].first - 1 + x1) / c[i].first;
		//i; i + x - 1;
		if (i + x - 1 >= n) continue;
		if (lx + x > 0 && (i + x < n && m[trm[i + x]] > 0 || i + x >= n)) continue;

		rep(i, i + x, j)
			answ1.push_back(c[j].second);

		mt k = -1;
		rep(0, i, j) {
			if (m[j] + x <= 0) {
				k = j;
				break;
			}
		}
		rep(i + x, n, j) {
			if (m[j] <= 0) {
				k = j;
				break;
			}
		}

		rep(k, n, j) {
			if (j < i || j >= i + x) answ2.push_back(c[j].second);
		}

		puts("Yes");
		if (sw) {
			printf("%d %d\n", answ2.size(), answ1.size());
			for (mt a : answ2) printf("%lld ", a);
			putc('\n', stdout);
			for (mt a : answ1) printf("%lld ", a);
			putc('\n', stdout);
		}
		else {
			printf("%d %d\n", answ1.size(), answ2.size());
			for (mt a : answ1) printf("%lld ", a);
			putc('\n', stdout);
			for (mt a : answ2) printf("%lld ", a);
			putc('\n', stdout);
		}

		ok = true;
		break;
	}
	if (!ok)
		puts("No");

	return 0;
}


#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <set>
#include <map>
#include <string>
#include <queue>
#include <stack>
#include <cstring>
#include <iterator>
#include <cmath>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <chrono>

#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")

using namespace std;
typedef long long mt;

template<typename T>
constexpr mt infValue = std::is_same<T, int>::value ? 2000100007 : 8600000000000000007ll;
template<typename T>
constexpr mt maxValue = std::is_same<T, int>::value ? 1000000007 : 1000000000000000001ll;

#define rep(a, b, i) for(register mt i = a; i < b; ++i)
#define repe(a, b, i) for(register mt i = a; i <= b; ++i)
#define repd(a, b, i) for(register mt i = a; i > b; --i)
#define repde(a, b, i) for(register mt i = a; i >= b; --i)

const mt INF = infValue<mt>;
const long long MOD = 1000000007ll;
const double EPS = 1e-6;
const mt MAX = maxValue<mt>;

#define N 300011
#define K 5001
#define P 18
#define M (2000111)

mt n, x1, x2;
pair<mt, mt> c[N];
bool sw, ok;
mt bs1(mt k) {//ff up
	mt l = -1, r = n - k;
	while (r - l > 1) {
		mt md = l + r >> 1;
		if (c[md].first * k >= x1) r = md;
		else l = md;
	}
	return r;
}

mt get(mt x, mt a, mt b) {
	mt cnt = n - x;
	if (x <= b)
		cnt -= b - x + 1;
	if (x <= a)
		cnt += a - x;
	return cnt;
}

mt bs2(mt a, mt b) {//ff down
	mt l = -1, r = n - 1;
	while (r - l > 1) {
		mt md = l + r >> 1;
		mt cx = get(md, a, b);
		if (c[md].first * cx >= x2) r = md;
		else l = md;
	}
	return r;
}

int main(void)
{
#ifdef _DEBUG
	freopen("in.txt", "r", stdin);
#endif
	scanf("%lld %lld %lld", &n, &x1, &x2);
	if (x1 < x2) swap(x1, x2), sw = true;
	rep(0, n, i)
		scanf("%lld\n", &c[i].first), c[i].second = i + 1;
	sort(c, c + n);
	repe(1, n, i) {
		//a; b;
		mt a = bs1(i);
		mt b = a + i - 1;
		if (c[a].first * i < x1) continue;
		mt a2 = bs2(a, b);
		if (c[a2].first * get(a2, a, b) < x2) continue;

		puts("Yes");
		if (sw) {
			printf("%lld %lld\n", get(a2, a, b), i);
			rep(a2, n, j)
				if (j < a || j > b) printf("%lld ", c[j].second);
			putc('\n', stdout);
			rep(0, i, j)
				printf("%lld ", c[a + j].second);
		}
		else {
			printf("%lld %lld\n", i, get(a2, a, b));
			rep(0, i, j)
				printf("%lld ", c[a + j].second);
			putc('\n', stdout);
			rep(a2, n, j)
				if(j < a || j > b) printf("%lld ", c[j].second);
		}

		ok = true;
		break;
	}
	if (!ok)
		puts("No");

	return 0;
}


#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <set>
#include <map>
#include <string>
#include <queue>
#include <stack>
#include <cstring>
#include <iterator>
#include <cmath>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <chrono>

#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")

using namespace std;
typedef long long mt;

template<typename T>
constexpr mt infValue = std::is_same<T, int>::value ? 2000100007 : 8600000000000000007ll;
template<typename T>
constexpr mt maxValue = std::is_same<T, int>::value ? 1000000007 : 1000000000000000001ll;

#define rep(a, b, i) for(register mt i = a; i < b; ++i)
#define repe(a, b, i) for(register mt i = a; i <= b; ++i)
#define repd(a, b, i) for(register mt i = a; i > b; --i)
#define repde(a, b, i) for(register mt i = a; i >= b; --i)

const mt INF = infValue<mt>;
const long long MOD = 1000000007ll;
const double EPS = 1e-6;
const mt MAX = maxValue<mt>;

#define N 300011
#define K 5001
#define P 18
#define M (2000111)

mt n, x1, x2;
pair<mt, mt> c[N];
bool sw, ok;
mt trm[N], m[N], lx;

vector<mt> answ1, answ2;

int main(void)
{
#ifdef _DEBUG
	freopen("in.txt", "r", stdin);
#endif
	scanf("%lld %lld %lld", &n, &x1, &x2);
	if (x1 < x2) swap(x1, x2), sw = true;
	rep(0, n, i)
		scanf("%lld\n", &c[i].first), c[i].second = i + 1;
	sort(c, c + n), trm[n] = n - 1, lx = INF;
	repde(n - 1, 0, i) {
		mt x = (c[i].first - 1 + x2) / c[i].first;
		mt nc = n - i;
		m[i] = x - nc;
		trm[i] = trm[i + 1];
		if (m[trm[i]] > m[i])
			trm[i] = i;
	}
	rep(0, n, i) {
		if(i) lx = min(lx, m[i - 1]);
		mt x = (c[i].first - 1 + x1) / c[i].first;
		//i; i + x - 1;
		if (i + x - 1 >= n) continue;
		if (lx + x > 0 && (i + x < n && m[trm[i + x]] > 0 || i + x >= n)) continue;

		rep(i, i + x, j)
			answ1.push_back(c[j].second);

		mt k = -1;
		rep(0, x, j) {
			if (m[j] + x <= 0) {
				k = j;
				break;
			}
		}
		rep(i + x, n, j) {
			if (m[j] <= 0) {
				k = j;
				break;
			}
		}
		rep(k, n, j) {
			if (c[j].second <= 0) c[j].second = lx + x;
			if (j < i || j >= i + x) answ2.push_back(c[j].second);
		}

		puts("Yes");
		if (sw) {
			printf("%d %d\n", answ2.size(), answ1.size());
			for (mt a : answ2) printf("%lld ", a);
			putc('\n', stdout);
			for (mt a : answ1) printf("%lld ", a);
			putc('\n', stdout);
		}
		else {
			printf("%d %d\n", answ1.size(), answ2.size());
			for (mt a : answ1) printf("%lld ", a);
			putc('\n', stdout);
			for (mt a : answ2) printf("%lld ", a);
			putc('\n', stdout);
		}

		ok = true;
		break;
	}
	if (!ok)
		puts("No");

	return 0;
}


#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <set>
#include <map>
#include <string>
#include <queue>
#include <stack>
#include <cstring>
#include <iterator>
#include <cmath>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <chrono>

#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")

using namespace std;
typedef long long mt;

template<typename T>
constexpr mt infValue = std::is_same<T, int>::value ? 2000100007 : 8600000000000000007ll;
template<typename T>
constexpr mt maxValue = std::is_same<T, int>::value ? 1000000007 : 1000000000000000001ll;

#define rep(a, b, i) for(register mt i = a; i < b; ++i)
#define repe(a, b, i) for(register mt i = a; i <= b; ++i)
#define repd(a, b, i) for(register mt i = a; i > b; --i)
#define repde(a, b, i) for(register mt i = a; i >= b; --i)

const mt INF = infValue<mt>;
const long long MOD = 1000000007ll;
const double EPS = 1e-6;
const mt MAX = maxValue<mt>;

#define N 300011
#define K 5001
#define P 18
#define M (2000111)

mt n, x1, x2;
pair<mt, mt> c[N];
bool sw, ok;
mt trm[N], m[N], lx;

vector<mt> answ1, answ2;

int main(void)
{
#ifdef _DEBUG
	freopen("in.txt", "r", stdin);
#endif
	scanf("%lld %lld %lld", &n, &x1, &x2);
	if (x1 < x2) swap(x1, x2), sw = true;
	rep(0, n, i)
		scanf("%lld\n", &c[i].first), c[i].second = i + 1;
	sort(c, c + n), trm[n] = n - 1, lx = INF;
	repde(n - 1, 0, i) {
		mt x = (c[i].first - 1 + x2) / c[i].first;
		mt nc = n - i;
		m[i] = x - nc;
		trm[i] = trm[i + 1];
		if (m[trm[i]] > m[i])
			trm[i] = i;
	}
	rep(0, n, i) {
		if(i) lx = min(lx, m[i - 1]);
		mt x = (c[i].first - 1 + x1) / c[i].first;
		//i; i + x - 1;
		if (i + x - 1 >= n) continue;
		if (lx + x > 0 && (i + x < n && m[trm[i + x]] > 0 || i + x >= n)) continue;

		rep(i, i + x, j)
			answ1.push_back(c[j].second);

		mt k = -1;
		rep(0, x, j) {
			if (m[j] + x <= 0) {
				k = j;
				break;
			}
		}
		rep(i + x, n, j) {
			if (m[j] <= 0) {
				k = j;
				break;
			}
		}
		if (k == -1) {
			answ2.push_back(0);
			answ2.push_back(lx + x);
			answ2.push_back(m[trm[i + x]]);
			answ2.push_back(11111);
			++k;
		}
		rep(k, n, j) {
			//if (c[j].second <= 0) c[j].second = lx + x;
			if (j < i || j >= i + x) answ2.push_back(c[j].second);
		}

		puts("Yes");
		if (sw) {
			printf("%d %d\n", answ2.size(), answ1.size());
			for (mt a : answ2) printf("%lld ", a);
			putc('\n', stdout);
			for (mt a : answ1) printf("%lld ", a);
			putc('\n', stdout);
		}
		else {
			printf("%d %d\n", answ1.size(), answ2.size());
			for (mt a : answ1) printf("%lld ", a);
			putc('\n', stdout);
			for (mt a : answ2) printf("%lld ", a);
			putc('\n', stdout);
		}

		ok = true;
		break;
	}
	if (!ok)
		puts("No");

	return 0;
}


#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <set>
#include <map>
#include <string>
#include <queue>
#include <stack>
#include <cstring>
#include <iterator>
#include <cmath>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <chrono>

#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")

using namespace std;
typedef long long mt;

template<typename T>
constexpr mt infValue = std::is_same<T, int>::value ? 2000100007 : 8600000000000000007ll;
template<typename T>
constexpr mt maxValue = std::is_same<T, int>::value ? 1000000007 : 1000000000000000001ll;

#define rep(a, b, i) for(register mt i = a; i < b; ++i)
#define repe(a, b, i) for(register mt i = a; i <= b; ++i)
#define repd(a, b, i) for(register mt i = a; i > b; --i)
#define repde(a, b, i) for(register mt i = a; i >= b; --i)

const mt INF = infValue<mt>;
const long long MOD = 1000000007ll;
const double EPS = 1e-6;
const mt MAX = maxValue<mt>;

#define N 300011
#define K 5001
#define P 18
#define M (2000111)

mt n, x1, x2;
pair<mt, mt> c[N];
bool sw, ok;
mt trm[N], m[N], lx;

vector<mt> answ1, answ2;

int main(void)
{
#ifdef _DEBUG
	freopen("in.txt", "r", stdin);
#endif
	scanf("%lld %lld %lld", &n, &x1, &x2);
	if (x1 < x2) swap(x1, x2), sw = true;
	rep(0, n, i)
		scanf("%lld\n", &c[i].first), c[i].second = i + 1;
	sort(c, c + n), trm[n] = n - 1, lx = INF;
	repde(n - 1, 0, i) {
		mt x = (c[i].first - 1 + x2) / c[i].first;
		mt nc = n - i;
		m[i] = x - nc;
		trm[i] = trm[i + 1];
		if (m[trm[i]] > m[i])
			trm[i] = i;
	}
	rep(0, n, i) {
		if(i) lx = min(lx, m[i - 1]);
		mt x = (c[i].first - 1 + x1) / c[i].first;
		//i; i + x - 1;
		if (i + x - 1 >= n) continue;
		if (lx + x > 0 && (i + x < n && m[trm[i + x]] > 0 || i + x >= n)) continue;

		rep(i, i + x, j)
			answ1.push_back(c[j].second);

		mt k = -1;
		rep(0, x, j) {
			if (m[j] + x <= 0) {
				k = j;
				break;
			}
		}
		rep(i + x, n, j) {
			if (m[j] <= 0) {
				k = j;
				break;
			}
		}
		rep(k, n, j) {
			if (j < i || j >= i + x) answ2.push_back(c[j].second);
		}

		puts("Yes");
		if (sw) {
			printf("%d %d\n", answ2.size(), answ1.size());
			for (mt a : answ2) printf("%lld ", a);
			putc('\n', stdout);
			for (mt a : answ1) printf("%lld ", a);
			putc('\n', stdout);
		}
		else {
			printf("%d %d\n", answ1.size(), answ2.size());
			for (mt a : answ1) printf("%lld ", a);
			putc('\n', stdout);
			for (mt a : answ2) printf("%lld ", a);
			putc('\n', stdout);
		}

		ok = true;
		break;
	}
	if (!ok)
		puts("No");

	return 0;
}


#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <set>
#include <map>
#include <string>
#include <queue>
#include <stack>
#include <cstring>
#include <iterator>
#include <cmath>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <chrono>

#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")

using namespace std;
typedef long long mt;

template<typename T>
constexpr mt infValue = std::is_same<T, int>::value ? 2000100007 : 8600000000000000007ll;
template<typename T>
constexpr mt maxValue = std::is_same<T, int>::value ? 1000000007 : 1000000000000000001ll;

#define rep(a, b, i) for(register mt i = a; i < b; ++i)
#define repe(a, b, i) for(register mt i = a; i <= b; ++i)
#define repd(a, b, i) for(register mt i = a; i > b; --i)
#define repde(a, b, i) for(register mt i = a; i >= b; --i)

const mt INF = infValue<mt>;
const long long MOD = 1000000007ll;
const double EPS = 1e-6;
const mt MAX = maxValue<mt>;

#define N 300011
#define K 5001
#define P 18
#define M (2000111)

mt n, x1, x2;
pair<mt, mt> c[N];
bool sw, ok;
mt trm[N], m[N], lx;

vector<mt> answ1, answ2;

int main(void)
{
#ifdef _DEBUG
	freopen("in.txt", "r", stdin);
#endif
	scanf("%lld %lld %lld", &n, &x1, &x2);
	if (x1 < x2) swap(x1, x2), sw = true;
	rep(0, n, i)
		scanf("%lld\n", &c[i].first), c[i].second = i + 1;
	sort(c, c + n), trm[n] = n - 1, lx = INF;
	repde(n - 1, 0, i) {
		mt x = (c[i].first - 1 + x2) / c[i].first;
		mt nc = n - i;
		m[i] = x - nc;
		trm[i] = trm[i + 1];
		if (m[trm[i]] > m[i])
			trm[i] = i;
	}
	rep(0, n, i) {
		if(i) lx = min(lx, m[i - 1]);
		mt x = (c[i].first - 1 + x1) / c[i].first;
		//i; i + x - 1;
		if (i + x - 1 >= n) continue;
		if (lx + x > 0 && (i + x < n && m[trm[i + x]] > 0 || i + x >= n)) continue;

		rep(i, i + x, j)
			answ1.push_back(c[j].second);

		mt k = -1;
		rep(0, x, j) {
			if (m[j] + x <= 0) {
				k = j;
				break;
			}
		}
		rep(i + x, n, j) {
			if (m[j] <= 0) {
				k = j;
				break;
			}
		}
		if (k == -1)
			answ2.push_back(101);
		rep(k, n, j) {
			//if (c[j].second <= 0) c[j].second = lx + x;
			if (j < i || j >= i + x) answ2.push_back(c[j].second);
		}

		puts("Yes");
		if (sw) {
			printf("%d %d\n", answ2.size(), answ1.size());
			for (mt a : answ2) printf("%lld ", a);
			putc('\n', stdout);
			for (mt a : answ1) printf("%lld ", a);
			putc('\n', stdout);
		}
		else {
			printf("%d %d\n", answ1.size(), answ2.size());
			for (mt a : answ1) printf("%lld ", a);
			putc('\n', stdout);
			for (mt a : answ2) printf("%lld ", a);
			putc('\n', stdout);
		}

		ok = true;
		break;
	}
	if (!ok)
		puts("No");

	return 0;
}