#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <set>

using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-7;
static const double PI = acos(-1.0);

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))

#include <complex>

typedef complex<double> Point;
typedef vector<Point> Polygon;

static const double INF = 1e+10;

#define CURR(P, i) (P[i])
#define NEXT(P, i) (P[(i + 1) % P.size()])

struct Line : public vector<Point> {
  Line() {;}
  Line(Point a, Point b) { push_back(a); push_back(b); }
};

struct Circle {
  Point p;
  double r;
  Circle() {;}
  Circle(Point p, double r) : p(p), r(r) {;}
};



// usage:
// g++ -Wall -Dvisualize hoge.cpp
// ./a.out 2> data.js
// firefox Visualize.html
int zoom = 10;
#ifdef visualize
void ChangeColor(int r, int g, int b) {
  fprintf(stderr, "c.strokeStyle = 'rgb(%d, %d, %d)';\n", r, g, b);
}
void DrawPoint(const Point &p) {
  fprintf(stderr, "circle(%d, %d, %d)\n",
      (int)(zoom*p.real()), 1980-(int)(zoom*p.imag()), 2);
}
void DrawLine(const Line &l) {
  fprintf(stderr, "line(%d, %d, %d, %d)\n",
      (int)(zoom*l[0].real()), 1980-(int)(zoom*l[0].imag()),
      (int)(zoom*l[1].real()), 1980-(int)(zoom*l[1].imag()));
}
void DrawCircle(const Circle &c) {
  fprintf(stderr, "circle(%d, %d, %d)\n",
      (int)(zoom * c.p.real()), 1980 - (int)(zoom * c.p.imag()), (int)(zoom * c.r));
}
#else
void DrawPoint(const Point &p) {;}
void ChangeColor(int r, int g, int b) {;}
void DrawLine(Line l) {;}
void DrawPolygon(const Polygon &p) {;}
void DrawCircle(Circle c) {;}
#endif

struct Rect {
  double x1, y1, x2, y2;
  Rect() {;}
  Rect(double x1, double y1, double x2, double y2) :
    x1(x1), y1(y1), x2(x2), y2(y2) {;}
};
void DrawRect(const Rect &rect) {
  DrawLine(Line(Point(rect.x1, rect.y1), Point(rect.x2, rect.y1)));
  DrawLine(Line(Point(rect.x2, rect.y1), Point(rect.x2, rect.y2)));
  DrawLine(Line(Point(rect.x2, rect.y2), Point(rect.x1, rect.y2)));
  DrawLine(Line(Point(rect.x1, rect.y2), Point(rect.x1, rect.y1)));
}

const double G = 9.8;
int n;
Rect rect[400];
double v, ex, ey;

// y = -G / 2 * t^2 + v * sinA * t
// x = v * cosA * t
// t = X / (v * cosA)

double Y(double theta, double x) {
  double t = x / (v * cos(theta));
  return -G / 2.0 * t * t + v * sin(theta) * t;
}

bool calc(double theta) {
  if (Y(theta, ex) - ey < -EPS) { return false; }
  double mx, my;
  {
    double left = 0.0;
    double right = 500;
    REP(iter, 100) {
      double midl = (left * 2.0 + right) / 3.0;
      double midr = (left + right * 2.0) / 3.0;
      double yl = Y(theta, midl);
      double yr = Y(theta, midr);
      if (yl > yr) {
        right = midr;
      } else {
        left = midl;
      }
    }
    mx = left;
    my = Y(theta, mx);
  }
  static int cnt = 0;
  cnt++;
  if (cnt == 11) {
    Point prev(0.0, 0.0);
    REP(x, 120) {
      Point next(x + 1, Y(theta, x + 1));
      DrawLine(Line(prev, next));
      prev = next;
    }
  }
  REP(i, n) {
    double ly = Y(theta, rect[i].x1);
    double ry = Y(theta, rect[i].x2);
    if (EPS >= rect[i].y2 - ly && EPS >= rect[i].y2 - ry) { continue; }
    if ((-EPS >= rect[i].y1 -ly && EPS <= rect[i].y2 - ry) ||
        (EPS <= rect[i].y2 - ly && -EPS >= rect[i].y1 - ry) ||
        (rect[i].y1 - ly < -EPS && EPS < rect[i].y2 - ly) ||
        (rect[i].y1 - ry < -EPS && EPS < rect[i].y2 - ry)) { return false; }
    if (EPS < rect[i].y2 - ly && EPS < rect[i].y2 - ry && rect[i].x1 <= mx && mx <= rect[i].x2 && rect[i].y1 - my <= -EPS) { return false; }
  }
  return true;
}

double CalcTheta(double left, double right, double tx, double ty, int dir) {
  REP(iter, 100) {
    double mid = (left + right) / 2.0;
    if (Y(mid, tx) < ty) {
      if (dir == 1) {
        right = mid;
      } else {
        left = mid;
      }
    } else {
      if (dir == 1) {
        left = mid;
      } else {
        right = mid;
      }
    }
  }
  return left;
}

bool OK(double tx, double ty) {
  double left = 0;
  double right = PI / 2 - EPS;
  REP(iter, 200) {
    double midl = (left * 2.0 + right) / 3.0;
    double midr = (left + right * 2.0) / 3.0;
    double yl = Y(midl, tx);
    double yr = Y(midr, tx);
    if (yl > yr) {
      right = midr;
    } else {
      left = midl;
    }
  }
  //if (Y(left, tx) - ty < -EPS) { return false; }
  bool ret = false;
  ret |= calc(CalcTheta(0, left, tx, ty, -1));
  ret |= calc(CalcTheta(left, PI / 2 - EPS, tx, ty, 1));
  return ret;
}

int main(int argc, char *argv[]) {
  if (argc > 1) { zoom = atoi(argv[1]); }
  while (scanf("%d %lf %lf %lf", &n, &v, &ex, &ey) > 0) {
    DrawCircle(Circle(Point(0, 0), 1));
    DrawCircle(Circle(Point(ex, ey), 1));
    REP(i, n) {
      double x1, x2, y1, y2;
      scanf("%lf %lf %lf %lf", &x1, &y1, &x2, &y2);
      if (x1 <= ex && ex <= x2 && y2 >= ey) {
        y2 = 1e+5;
      }
      x2 = min(x2, ex + EPS);
      if (ex < x1) {
        x1 = 1e+5;
        x2 = 2e+5;
        y1 = 1e+5;
        y2 = 2e+5;
      }
      rect[i] = Rect(x1, y1, x2, y2);
      DrawRect(rect[i]);
    }
    bool ok = false;
    ok |= OK(ex, ey + EPS);
    REP(i, n) {
      if (ok) { break; }
      ok |= OK(rect[i].x1, rect[i].y2 + EPS);
      ok |= OK(rect[i].x2, rect[i].y2 + EPS);
      ok |= OK(rect[i].x1, rect[i].y1 - EPS);
      ok |= OK(rect[i].x2, rect[i].y1 - EPS);
    }
    puts(ok ? "Yes" : "No");
  }
}

Measured memory_bytes: 0