/*
 * _|_|_|_|_|  _|_|_|_|    _|_|_|  _|_|_|_|_|  _|_|_|      _|_|
 *       _|    _|        _|                _|        _|  _|    _|
 *     _|      _|_|_|      _|_|          _|      _|_|        _|
 *   _|        _|              _|      _|            _|    _|
 * _|_|_|_|_|  _|        _|_|_|      _|        _|_|_|    _|_|_|_|
 */

#include<bits/stdc++.h>

const int maxN = 1e5 + 1, maxM = 17;

const long double eps = 1e-8;

long double f[maxM][maxN];
long double ct[maxN], s[maxN], d[maxN], sd[maxN], v[maxN];

inline long double GetV() {
  long double x, y;
  return std::cin >> x >> y, x / y;
}

inline long double Query(int l, int r) {
  if (r < l)
    return 0;

  int k = std::__lg(r - l + 1);
  return std::max(f[k][l], f[k][r - (1 << k) + 1]);
}

int main() {
#ifdef LOCAL
  freopen("task.in", "r", stdin);
  freopen("task.out", "w", stdout);
  freopen("task.err", "w", stderr);
#endif
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);

  int n, ans = 1;
  long double D, V;
  std::cin >> n >> D, V = GetV();

  for (int i = 1; i <= n; i++) {
    std::cin >> s[i] >> d[i];
    sd[i] = sd[i - 1] + d[i];
    v[i] = GetV();
  }

  std::vector<int> sta;
  sta.emplace_back(n);
  f[0][n] = ct[n] = 1e20;

  auto Catch = [&](int x, int i) {
    long double diff = (s[x] - s[i]) - (sd[x] - sd[i]);
    return diff / (v[i] - v[x]);
  };

  for (int i = n - 1; i >= 1; i--) {
    auto Check = [&](int x) {
      long double t1 = Query(i + 1, x - 1);
      long double t2 = Catch(x, i);
      return t2 - t1 > -eps;
    };

    while (!sta.empty() && v[sta.back()] - v[i] > -eps)
      sta.pop_back();

    if (!sta.empty()) {
      int l = 0, r = int(sta.size() - 1);

      while (l < r) {
        int mid = (l + r) >> 1;

        if (Check(sta[mid]))
          r = mid;
        else
          l = mid + 1;
      }

      ct[i] = Catch(sta[l], i);
    } else
      ct[i] = 1e20;

    f[0][i] = ct[i];
    sta.emplace_back(i);

    for (int j = 1; i + (1 << j) - 1 <= n; j++)
      f[j][i] = std::max(f[j - 1][i], f[j - 1][i + (1 << (j - 1))]);
  }

  for (int i = 1; i < n; i++) {
    long double t = (D + s[i]) / (V - v[i]);

    if (ct[i] <= t)
      continue;

    int l = i + 1, r = n;

    while (l < r) {
      int mid = (l + r + 1) >> 1;

      if (t - Query(i + 1, mid - 1) > -eps)
        l = mid;
      else
        r = mid - 1;
    }

    long double pos = s[l] + t * v[l] - (sd[l] - sd[i]);
    long double diff = pos - (t * v[i] + s[i]);
    ans += diff >= D;
  }

  std::cout << ans << '\n';

  return 0;
}