// Slower C++ solution:
/*

 * Author: FreeIdea

 * Created Time:  2011/10/22 17:01:43

 * File Name: I.cpp

 */

#include <iostream>

#include <string>

#include <cstdio>

#include <cstring>

#include <cmath>

#include <cstdlib>

#include <algorithm>

#include <vector>

using namespace std;

const int maxint = -1u>>1;

template <class T> bool get_max(T& a, const T &b) {return b > a? a = b, 1: 0;}

template <class T> bool get_min(T& a, const T &b) {return b < a? a = b, 1: 0;}



int n;

double v, X, Y, L[64], R[64], B[64], T[64], vx, vy;



bool solve();

bool check();

double get_y(double x);



int main() {

    while (solve());

    return 0;

}



bool solve() {

    if (scanf("%d%lf%lf%lf", &n, &v, &X, &Y) == EOF)

        return false;

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

        scanf("%lf%lf%lf%lf", &L[i], &B[i], &R[i], &T[i]);

        if (L[i] > R[i])

            swap(L[i], R[i]);

        if (B[i] > T[i])

            swap(B[i], T[i]);

    }

    double step = 0.0001;

    for (vx = step; vx <= v; vx += step) {

        vy = sqrt(v * v - vx * vx);

        if (check()) {

            //printf("-- %lf %lf\n", vx, vy);

            puts("Yes");

            return true;

        }

    }

    puts("No");

    return true;

}



bool check() {

    double bx = X, by = get_y(X);

    if (by < Y)

        return false;

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

        if (L[i] < X) {

            double l = L[i], r = min(X, R[i]);

            double y1 = get_y(l), y2 = get_y(r);

            //printf("-- %lf %lf %lf %lf\n", l, y1, r, y2);

            if (y1 >= B[i] && y1 <= T[i])

                return false;

            if (y2 >= B[i] && y2 <= T[i])

                return false;

            if (y1 <= B[i] && y2 >= B[i])

                return false;

            if (y1 >= B[i] && y2 <= B[i])

                return false;

            if (y1 <= T[i] && y2 >= T[i])

                return false;

            if (y1 >= T[i] && y2 <= T[i])

                return false;

        }

        if (L[i] <= bx && R[i] >= bx) {

            if (B[i] <= Y && T[i] >= Y)

                return false;

            if (B[i] >= Y && B[i] <= by)

                return false;

        }

    }

    return true;

}



double get_y(double x) {

    double t = x / vx;

    return vy * t - 0.5 * 9.8 * t * t;

}

// Faster C++ solution for the same problem (measured speedup: 5.614128773136383x):
#include <cstdio>

#include <cmath>

#include <algorithm>

#define eps 1e-8

using namespace std;

double L[100],R[100],B[100],T[100];

double X,Y,v,g=9.8;

int n;

int sgn(double x)

{

	return x<-eps?-1:x>eps;

}

int ck(double a,double b,double c)

{

	if(sgn(a-c)*sgn(b-c)<0) return 1;

	return 0;

}

int ck(double h)

{

	//printf("%f\n",h);

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

		if(sgn(L[i]-X)<=0) {

			double x=L[i];

			double y1=h*x-g/2/v/v*x*x*(1+h*h);

			if(sgn(y1-T[i])<0&&sgn(y1-B[i])>0) return 0;

			if(sgn(R[i]-X)>=0) x=X;

			else x=R[i];

			double y2=h*x-g/2/v/v*x*x*(1+h*h);

			if(ck(y1,y2,B[i])||ck(y1,y2,T[i])||ck(y1,y2,(B[i]+T[i])/2)) return 0;

		}

		if(sgn(R[i]-X)<=0){

			double x=R[i];

			double y=h*x-g/2/v/v*x*x*(1+h*h);

			if(sgn(y-T[i])<0&&sgn(y-B[i])>0) return 0;

		}

	}

	double y=h*X-g/2/v/v*X*X*(1+h*h);

	//printf("%f\n",y);

	if(sgn(y-Y)>=0) return 1;

	return 0;

}

int ck(double x,double y)

{

	if(sgn(x)==0) return 0;

	double a=-g/2/v/v*x*x;

	double b=x;

	double c=-g/2/v/v*x*x-y;

	double w=b*b-4*a*c;

	if(sgn(w)<0) return 0;

	w=sqrt(w);

	double h1=(-b+w)/(2*a);

	if(ck(h1)) return 1;

	h1=(-b-w)/(2*a);

	return ck(h1);

}

int main()

{

	scanf("%d%lf%lf%lf",&n,&v,&X,&Y);

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

		scanf("%lf%lf%lf%lf",L+i,B+i,R+i,T+i);

	int flag=0;

	if(sgn(v)){

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

			if(ck(L[i],B[i])||ck(R[i],B[i])||ck(L[i],T[i])||ck(R[i],T[i])) {

				flag=1;

				break;

			}

		}

	}

	if(ck(X,Y)) flag=1;

	if(flag) puts("Yes");

	else puts("No");

}

/***

0 7 3 1

0.466667

2.866667

No

***/