#include <bits/stdc++.h>
using namespace std;

typedef complex<double> P;

const double g = 9.8; // Gravity
const double EPS = 1e-6;
const double EPSB = 1e-10;
const double INF = 1e+9;

struct Rect{
  P ll, ur; // low_left, up_right
  P p[4];
  Rect(P ll=P(), P ur=P()):ll(ll),ur(ur){
    p[0] = ll;
    p[1] = P(real(ll), imag(ur));
    p[2] = ur;
    p[3] = P(real(ur), imag(ll));
  }
};

bool equal(double a, double b){
  return fabs(a-b) < EPS;
}


int n;
double v;
P target;
vector<Rect> rv;

double calc_y(double rad, double x){
  return -g / (2.0 * v*v * cos(rad)*cos(rad)) * x*x + tan(rad) * x;
}

// if y == 0, calc x
double calc_x_y0(double rad){
  double a = -g / (2.0 * v*v * cos(rad)*cos(rad));
  double b = tan(rad);
  return -b / a;
}

bool is_up(double rad, double x){
  return x < calc_x_y0(rad) / 2.0 - EPS;
}

vector<double> calc_rad(double x, double y){
  vector<double> res;
  double le = 0, mid1, mid2, ri = M_PI / 2.0 - EPS, res1, res2;

  while(ri - le > EPSB){
    mid1 = (le * 2.0 + ri) / 3.0;
    mid2 = (le + ri * 2.0) / 3.0;
    if(calc_y(le, x) < calc_y(mid1, x) && calc_y(mid1, x) < calc_y(mid2, x)) le = mid1;
    else ri = mid2;
  }
  res1 = (ri + le) / 2.0;

  //cout << res1*180.0/M_PI << ' ' << calc_y(res1, x) << ", " << y << endl;
  //if(calc_y(res1, x) < y - EPS) return res;

  le = 0, ri = res1;
  while(ri - le > EPSB){
    mid1 = (le + ri) / 2.0;
    if(calc_y(mid1, x) > y) ri = mid1;
    else le = mid1;
  }
  res2 = (ri + le) / 2.0;

  //printf("%.10f\n", calc_y(res2, real(target)));
  if(/*equal(calc_y(res2, x), y) &&*/ calc_y(res2, real(target)) >= imag(target) - EPS) res.push_back(res2);

  le = res1, ri = M_PI / 2.0 - EPS;
  while(ri - le > EPSB){
    mid1 = (le + ri) / 2.0;
    if(calc_y(mid1, x) > y) le = mid1;
    else ri = mid1;
  }
  res2 = (ri + le) / 2.0;

  if(/*equal(calc_y(res2, x), y) &&*/ calc_y(res2, real(target)) >= imag(target) - EPS) res.push_back(res2);

  return res;
}

bool hit_rect(double rad){
  for(int i=0;i<n;i++){
    double x[2] = {real(rv[i].ll), min(real(target), real(rv[i].ur))};
    double y[2] = {imag(rv[i].ll), imag(rv[i].ur)};
    if(x[0] > real(target) + EPS) continue;
    if(calc_y(rad, x[0]) < y[0] - EPS && calc_y(rad, x[1]) > y[0] + EPS || calc_y(rad, x[0]) > y[1] + EPS && calc_y(rad, x[1]) < y[1] - EPS) return true;
    if(calc_y(rad, x[0]) > y[0] + EPS && calc_y(rad, x[0]) < y[1] - EPS) return true;
    if(equal(calc_y(rad, x[0]), y[0]) && is_up(rad, x[0]) || equal(calc_y(rad, x[1]), y[1]) && !is_up(rad, x[1])) return true;
  }
  return false;
}

bool solve(){
  vector<double> calc_res;

  for(int i=0;i<n;i++){
    for(int j=0;j<=3;j++){
      vector<double> cr = calc_rad(real(rv[i].p[j]), imag(rv[i].p[j]));
      for(int k=0;k<cr.size();k++){
        calc_res.push_back(cr[k]);
      }
    }
  }
  //cout << "calc_res.size = " << calc_res.size() << endl;
  vector<double> cr = calc_rad(real(target), imag(target));
  for(int i=0;i<cr.size();i++){
    calc_res.push_back(cr[i]);
  }
  //cout << "calc_res.size = " << calc_res.size() << endl;

  for(int i=0;i<calc_res.size();i++){
    if(!hit_rect(calc_res[i])) {
      //cout << calc_res[i] * 180.0 / M_PI << endl;
      return true;
    }
  }
  return false;
}

int main(){
  double x, y, x2, y2;
  while(cin >> n >> v >> x >> y){
    rv.clear();
    target = P(x, y);
    for(int i=0;i<n;i++){
      cin >> x >> y >> x2 >> y2;
      rv.push_back(Rect(P(x, y), P(x2, y2)));
    }
    cout << (solve() ? "Yes" : "No") << endl;
  }
}

Measured memory_bytes: 1348