/*
// Sol 1 - 40 p

# include <fstream>
using namespace std;

ifstream f ("minim2.in");
ofstream g ("minim2.out");

double A[200010];
int n, i, step;
double AB[100010];
double a, b, r, s;

inline int son1 (int dad)
{
	return dad << 1;
}

inline int son2 (int dad)
{
	return (dad << 1) + 1;
}

void remove_heap (double heap[])
{
	int poz = 1;
	for (; ; )
	{
		int s1 = son1 (poz), s2 = son2 (poz), ok = 0;
		
		if (s1 <= n && heap[s1] - heap[s1] * AB[s1] > heap[s2] - heap[s2] * AB[s2] && heap[s1] - heap[s1] * AB[s1] > heap[poz] - heap[poz] * AB[poz])
		{
			swap (s1, poz);
			swap (heap[s1], heap[poz]);
			swap (AB[s1], AB[poz]);
			ok = 1;
		}
		else
		if (s2 <= n && heap[s2] - heap[s2] * AB[s2] > heap[poz] - heap[poz] * AB[poz])
		{
			swap (s2, poz);
			swap (heap[s2], heap[poz]);
			swap (AB[s2], AB[poz]);
			ok = 1;
		}
		if (!ok) break ;
	}
}

int main ()
{
	f >> n;
	for (i = 1; i <= n; ++i)
		f >> A[i], s += A[i];
	
	make_heap (A + 1, A + n + 1);
	
	f >> a >> b >> r;
	
	for (i = 1; i <= n; ++i)
		AB[i] = a;
	
	while (s >= r)
	{
		s -= A[1];
		s += A[1] * AB[1];
		A[1] = A[1] * AB[1];
		AB[1] = b;
		remove_heap (A);
		++step;
	}
	
	g << step << '\n';
	
	return 0;
}

*/

/* // Sol 2- 70p

#include <fstream>
using namespace std;

ifstream F("minim2.in");
ofstream G("minim2.out");

#define Nmax 100011

int Max;
double A[Nmax];
int Leg[Nmax],Last[Nmax],Poz[Nmax];
double First[Nmax];
int N; 
double V,v;
double S;
double T;
int Co;

int pozitionare(int st,int dr)
{
	int xst,xdr;
	xst=0;
	xdr=-1;
	while (st<dr)
		if (A[st]>A[dr])
		{
			st+=xst;
			dr+=xdr;
		}
	else
	{
        swap(A[st],A[dr]);
        xst=1-xst;
        xdr=-1-xdr;
        st+=xst;
		dr+=xdr;
	}
	return st;
}

void quick(int st,int dr)
{
	int p=pozitionare(st,dr);
	if (st<p-1)
		quick(st,p-1);
	if (p+1<dr)
		quick(p+1,dr);
}

int main()
{
	F>>N;
	S=0.0;
	for (int i=1;i<=N;++i)
		F>>A[i],S+=A[i];	
	
	quick(1,N);
	for (int i=1;i<=N;++i)
		Leg[i]=i+1;
	First[0]=1;
	Last[0]=N;
	Poz[0]=1;
	Max=0;
	
	F>>V>>v;
	V=1-V;v=1-v;
	
	while (S<T)
	{
		double Sm=First[0]*V;
		int Pm=0;
		for (int i=1;i<=Max;++i)
			if ( Sm<First[i]*v )
				Sm=First[i]*v,Pm=i;
		
		if (! First[Pm+1])
		{
			Poz[Pm+1]=Poz[Pm];
			First[Pm+1]=Sm;
			Last[Pm+1]=Poz[Pm];
		}
		else
		{
			Leg[Last[Pm+1]]=Poz[Pm];
			Last[Pm+1]=Poz[Leg[Last[Pm+1]]];
		}
		
		First[Pm]=A[Leg[Poz[Pm]]];
		Poz[Pm]=Leg[Poz[Pm]];
		++Co;
		
		S-=Sm;
	}
	
	G<<Co;
	
	F.close();
	G.close();
	return 0;
}

*/

// Sol 3 -100p

#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;

#define maxn 100010
#define maxp 13
#define eps 0.000001

int n, i, j, k, sol, csol;
double v[maxn], bpt[maxp];
double a, b, r, sum;
vector<double> t;

double reduce(double x, double value)
{
    if(x*(1-a)<value)
        return x;

    if(x*a*(1-b)<value)
    {
        ++csol;
        t.push_back(x*(1-a));
        return x*a;
    }

    x=x*a;
    csol+=2;
    for(int i=maxp-1; i>=0; --i)
        if(x*bpt[i]*(1-b)>=value)
        {
            csol+=(1<<i);
            x*=bpt[i];
        }

    t.push_back(x*(1-b));
    return x*b;
}

int check(double value)
{
    double csum=0;

    t.clear();
    csol=0;
    for(int i=1; i<=n; ++i)
        csum+=reduce(v[i], value);

    sort(t.begin(), t.end());
    for(int i=0; i<t.size(); ++i)
        if(csum+t[i]<r+eps)
        {
            --csol;
            csum+=t[i];
        }
        else
            break;

    if(csum<r+eps)
        return 1;
    return 0;
}

int main()
{
    freopen("minim2.in", "r", stdin);
    freopen("minim2.out", "w", stdout);

    scanf("%d", &n);
    for(int i=1; i<=n; ++i)
        scanf("%lf", &v[i]);

    scanf("%lf%lf%lf", &a, &b, &r);

    bpt[0]=b;
    for(int i=1; i<maxp; ++i)
        bpt[i]=bpt[i-1]*bpt[i-1];

    double left=0, med, right=1000000000;

    sol=1000000000;
    for(int i=1; i<=48; ++i)
    {
        med=(left+right)/2;
        if(check(med))
        {
            sol=min(csol, sol);
            left=med;
        }
        else
            right=med;
    }

    printf("%d\n", sol);
    return 0;
}