//#include "bits/stdc++.h"

#define _USE_MATH_DEFINES
#include <cmath>
#include <cstdlib>
#include <deque>
#include <algorithm>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <iterator>
#include<complex>

using namespace std;

#define rep(i,a,b) for(int i=(a), i##_len=(b);i<i##_len;i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define all(c) begin(c),end(c)

//#define int long long
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair

typedef long long ll;
//typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<double, double> pdd;
typedef vector<vector<int>> mat;

template<class T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (b < a) { a = b; return true; } return false; }

const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;

typedef complex<double> P;
typedef vector<P> G;

bool operator < (const P& a, const P& b) {
	return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}

double cross(const P& a, const P& b) {
	return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {
	return real(conj(a)*b);
}

struct L : public vector<P> {
	L(const P &a, const P &b) {
		push_back(a); push_back(b);
	}
};

struct C {
	P p; double r;
	C(const P &p, double r) : p(p), r(r) { }
};

int ccw(P a, P b, P c) {
	b -= a; c -= a;
	if (cross(b, c) > 0)   return +1;       // counter clockwise
	if (cross(b, c) < 0)   return -1;       // clockwise
	if (dot(b, c) < 0)     return +2;       // c--a--b on line
	if (norm(b) < norm(c)) return -2;       // a--b--c on line
	return 0;
}

bool intersectLL(const L &l, const L &m) {
	return abs(cross(l[1] - l[0], m[1] - m[0])) > EPS || // non-parallel
		abs(cross(l[1] - l[0], m[0] - l[0])) < EPS;   // same line
}
bool intersectLS(const L &l, const L &s) {
	return cross(l[1] - l[0], s[0] - l[0])*       // s[0] is left of l
		cross(l[1] - l[0], s[1] - l[0]) < EPS; // s[1] is right of l
}
bool intersectLP(const L &l, const P &p) {
	return abs(cross(l[1] - p, l[0] - p)) < EPS;
}
bool intersectSS(const L &s, const L &t) {
	return ccw(s[0], s[1], t[0])*ccw(s[0], s[1], t[1]) <= 0 &&
		ccw(t[0], t[1], s[0])*ccw(t[0], t[1], s[1]) <= 0;
}
bool intersectSP(const L &s, const P &p) {
	return abs(s[0] - p) + abs(s[1] - p) - abs(s[1] - s[0]) < EPS; // triangle inequality
}

P projection(const L &l, const P &p) {
	double t = dot(p - l[0], l[0] - l[1]) / norm(l[0] - l[1]);
	return l[0] + t*(l[0] - l[1]);
}
P reflection(const L &l, const P &p) {
	return p + 2.0*(projection(l, p) - p);
}
double distanceLP(const L &l, const P &p) {
	return abs(p - projection(l, p));
}
double distanceLL(const L &l, const L &m) {
	return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
double distanceLS(const L &l, const L &s) {
	if (intersectLS(l, s)) return 0;
	return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
double distanceSP(const L &s, const P &p) {
	const P r = projection(s, p);
	if (intersectSP(s, r)) return abs(r - p);
	return min(abs(s[0] - p), abs(s[1] - p));
}
double distanceSS(const L &s, const L &t) {
	if (intersectSS(s, t)) return 0;
	return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
		min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
P crosspoint(const L &l, const L &m) {
	double A = cross(l[1] - l[0], m[1] - m[0]);
	double B = cross(l[1] - l[0], l[1] - m[0]);
	if (abs(A) < EPS && abs(B) < EPS) return m[0]; // same line
	//if (abs(A) < EPS) assert(false); // !!!PRECONDITION NOT SATISFIED!!!
	return m[0] + B / A * (m[1] - m[0]);
}

const double g = 9.8;
int N, V, X, Y;
int PL[50], PB[50], PR[50], PT[50];

double calc(double vy, double t)
{
	return vy*t - g*t*t / 2;
}

int cmp(double lb, double ub, double a)
{
	return a<lb + EPS ? -1 : a>ub - EPS ? 1 : 0;
}

bool check(double qx, double qy)
{
	double a = g*g / 4, b = g*qy - V*V, c = qx*qx + qy*qy;
	double D = b*b - 4 * a*c;
	if (D<0 && D>-EPS)D = 0;
	if (D < 0)return false;
	for (int d = -1; d <= 1; d += 2)
	{
		double t2 = (-b + d*sqrt(D)) / (2 * a);
		if (t2 <= 0)continue;
		double t = sqrt(t2);
		double vx = qx / t, vy = (qy + g*t*t / 2) / t;

		double yt = calc(vy, X / vx);
		if (yt < Y - EPS)continue;

		bool ok = true;
		rep(i, 0, N)
		{
			if (PL[i] >= X)continue;
			if (PR[i] == X&&Y <= PT[i] && PB[i] <= yt)ok = false;
			int yL = cmp(PB[i], PT[i], calc(vy, PL[i] / vx));
			int yR = cmp(PB[i], PT[i], calc(vy, PR[i] / vx));
			int xH = cmp(PL[i], PR[i], vx*(vy / g));
			int yH = cmp(PB[i], PT[i], calc(vy, vy / g));
			if (xH == 0 && yH >= 0 && yL < 0)ok = false;
			if (yL*yR <= 0)ok = false;
		}
		if (ok)return true;
	}
	return false;
}

int main()
{
	cin.tie(0);
	ios::sync_with_stdio(false);

	cin >> N >> V >> X >> Y;
	rep(i, 0, N)
	{
		cin >> PL[i] >> PB[i] >> PR[i] >> PT[i];
		chmin(PR[i], X);
	}

	bool ok = check(X, Y);
	rep(i, 0, N)
	{
		ok |= check(PL[i], PT[i]);
		ok |= check(PR[i], PT[i]);
	}

	cout << (ok ? "Yes" : "No") << endl;

	return 0;
}


Measured memory_bytes: 3228