// Original C++ solution (slower):
#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <cmath>

#include <iostream>

#include <algorithm>

#include <vector>



using namespace std;



const long long N = 10000;

vector<long long> f[N];

vector<long long> pack;

long long n, l, m ,r;



int main()

{

	ios::sync_with_stdio(false);

	cin >> n >> l >> m >> r;

	l *= 2; m *= 2; r *= 2;

	for (long long i = 0; i <= n; ++i)

		f[i] = vector<long long>(m + 10, 0);

	for (long long i = 0; i < n; ++i) {

		long long weight;

		cin >> weight;

		pack.push_back(weight);

	}

	f[0][0] = 1;

	f[0][1] = -1;

	for (long long i = 0; i <= n; ++i) {

		for (long long j = 1; j <= m; ++j)

			f[i][j] += f[i][j - 1];

		if (i == n) break;

		for (long long j = 0; j <= m; ++j) {

			if (!f[i][j]) continue;

			long long kl = r * pack[i], kr = l / 2 * pack[i];

			long long cl, cr;

			//part1

			if(j - kl >= 0 && j - kr >= 0) {

				cl = j - kr;

				cr = j - kl;

			} else if (j - kl <= 0 && j - kr <= 0) {

				cl = abs(j - kl);

				cr = abs(j - kr);

			} else {

				cl = 0;

				cr = max(abs(j - kr), abs(j - kl));

			}

			if(cl <= m) {

				cr = min(cr, m);

				f[i + 1][cl]++;

				f[i + 1][cr + 1]--;

			}

			//part2

			cl = j + kl, cr = j + kr;

			if(cl <= m) {

				cr = min(cr, m);

				f[i + 1][cl]++;

				f[i + 1][cr + 1]--;

			}

					

		}

	}

	for (long long i = 0; i <= m; ++i)

		if (f[n][i]) {

			cout << "Yes" << endl;

			return 0;

		}

	cout << "No" << endl;

	return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <cassert>

#include <vector>

#include <algorithm>



std::vector <std::pair <double, double> > list;



double l, m, r;



inline std::pair <double, double> operator + (std::pair <double, double> a, std::pair <double, double> b)

{

	return std::make_pair(a.first + b.first, a.second + b.second);

}



inline std::pair <double, double> operator - (std::pair <double, double> a, std::pair <double, double> b)

{

	return std::make_pair(a.first - b.second, a.second - b.first);

}



inline std::pair <double, double> inter(std::pair <double, double> a, std::pair <double, double> b)

{

	return std::make_pair(std::max(a.first, b.first), std::min(a.second, b.second));

}



inline bool check(double x)

{

	std::pair <double, double> delta = std::make_pair(r * x, l * x);

	std::vector <std::pair <double, double> > tmp;

	bool flag = false;

	for (int i = 0; i < (int)list.size(); i ++)

	{

		std::pair <double, double> now = inter(list[i] + delta, std::make_pair(-m, m));

		if (now.first <= now.second)

		{

			flag = true;

			tmp.push_back(now);

		}

		now = inter(list[i] - delta, std::make_pair(-m, m));

		if (now.first <= now.second)

		{

			flag = true;

			tmp.push_back(now);

		}

	}

	list.clear();

	if (!flag)

		return false;

	std::sort(tmp.begin(), tmp.end());

	for (int i = 0; i < (int)tmp.size(); i ++)

	{

		double nowr = tmp[i].second;

		int r = i;

		while (r + 1 < (int)tmp.size() && tmp[r + 1].second <= nowr)

		{

			r ++;

			nowr = std::max(nowr, tmp[r].second);

		}

		list.push_back(std::make_pair(tmp[i].first, nowr));

		i = r;

	}

	return true;

}



int main()

{

	int n;

	scanf("%d%lf%lf%lf", &n, &l, &m, &r);

	assert(n <= 1000);

	l /= 2;

	list.push_back(std::make_pair(0, 0));

	bool ans = true;

	for (int i = 1; i <= n; i ++)

	{

		double x;

		scanf("%lf", &x);

		if (ans)

			ans = check(x);

	}

	if (ans)

		puts("Yes");

	else

		puts("No");

	return 0;

}

// Fastest known solution for this problem: