#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using P = pair<int, int>;
const double eps = 1e-8;
const ll MOD = 1000000007;
const int INF = INT_MAX / 2;
const ll LINF = LLONG_MAX / 2;
template<typename T1, typename T2>
bool chmax(T1 &a, const T2 &b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template<typename T1, typename T2>
bool chmin(T1 &a, const T2 &b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> p) {
  os << p.first << ":" << p.second;
  return os;
}
template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
  for(int i=0;i<((int)(v.size()));++i) {
    if (i) os << " ";
    os << v[i];
  }
  return os;
}
struct Rect {
  double l, b, r, t;
};
int n;
double v, X, Y;
const double g = 9.8;
vector<Rect> rect;
bool hanbetu(double a, double b, double c) {
  return b * b - 4 * a * c + eps > 0;
}
pair<double, double> get_vx(double a, double b, double c) {
  double tmp1 = - b / (2 * a);
  double tmp2 = sqrt(b * b - 4 * a * c + eps) / (2 * a);
  return make_pair(tmp1 + tmp2, tmp1 - tmp2);
}
double get_val(double vx, double nowx) {
  double vy = sqrt(v * v - vx * vx);
  return -(g / (2 * vx * vx)) * (nowx - vx * vy / g) * (nowx - vx * vy / g) + vy * vy / (g * 2);
}
bool seihu(int i, double vx) {
  vector<double> px = {rect[i].l, rect[i].l, rect[i].r, rect[i].r};
  vector<double> py = {rect[i].b, rect[i].t, rect[i].b, rect[i].t};
  int sign = -1;
  bool res = true;
  for(int j=0;j<(4);++j) {
    if(X < px[j]) continue;
    double val = get_val(vx, px[j]) - py[j];
    if(sign == -1 && abs(val) > eps) {
      sign = val > 0;
    } else if(abs(val) > eps) {
      res &= (val > 0) == sign;
    }
  }
  double vy = sqrt(v * v - vx * vx);
  double jiku = vx * vy / g;
  double jikuy = vy * vy / (2 * g);
  res &= jiku < rect[i].l || rect[i].r < jiku || jikuy < rect[i].b || rect[i].t < jikuy;
  if(rect[i].r < X) {
    return res;
  } else {
    res = true;
    double vall = get_val(vx, rect[i].l);
    double valx = get_val(vx, X);
    if(vall > rect[i].t) {
      return valx > rect[i].t;
    } else if(vall < rect[i].b) {
      return valx < rect[i].b && (X < jiku || jikuy < rect[i].b);
    } else {
      return false;
    }
  }
}
bool pig(int i, double vx) {
  double val1 = get_val(vx, X);
  return Y > rect[i].t || val1 < rect[i].b;
}
bool check(double x, double y) {
  if(x == 0) return false;
  double a = 1 + y * y / (x * x);
  double b = g * y - v * v;
  double c = g * g * x * x / 4;
  if(!hanbetu(a, b, c)) return false;
  auto p_vx = get_vx(a, b, c);
  bool res_fi = true;
  if(p_vx.first < -eps || v * v - p_vx.first < -eps) res_fi = false;
  else p_vx.first = sqrt(p_vx.first);
  for(int i=0;i<(n);++i) {
    if(!res_fi) break;
    if(rect[i].l < X) res_fi &= seihu(i, p_vx.first);
    if(rect[i].l < X && X < rect[i].r) res_fi &= pig(i, p_vx.first);
  }
  res_fi &= Y < get_val(p_vx.first, X) + eps;
  bool res_se = true;
  if(p_vx.second < -eps || v * v - p_vx.second < -eps) res_se = false;
  else p_vx.second = sqrt(p_vx.second);
  for(int i=0;i<(n);++i) {
    if(!res_se) break;
    if(rect[i].l < X) res_se &= seihu(i, p_vx.second);
    if(rect[i].l < X && X < rect[i].r) res_se &= pig(i, p_vx.second);
  }
  res_se &= Y < get_val(p_vx.second, X) + eps;
  return res_fi || res_se;
}
int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(10);
  cin >> n >> v >> X >> Y;
  for(int i=0;i<(n);++i) {
    double l, b, r, t; cin >> l >> b >> r >> t;
    rect.push_back({l, b, r, t});
  }
  bool ans = false;
  for(int i=0;i<(n);++i) {
    ans |= check(rect[i].l, rect[i].t);
    ans |= check(rect[i].r, rect[i].t);
  }
  ans |= check(X, Y);
  cout << (ans ? "Yes" : "No") << endl;
}



Measured memory_bytes: 3288