//#define NDEBUG
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <utility>
#include <vector>

namespace n91 {

using i8 = std::int_fast8_t;
using i32 = std::int_fast32_t;
using i64 = std::int_fast64_t;
using u8 = std::uint_fast8_t;
using u32 = std::uint_fast32_t;
using u64 = std::uint_fast64_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;

struct rep {
  struct itr {
    usize i;
    constexpr itr(const usize i) noexcept : i(i) {}
    void operator++() noexcept { ++i; }
    constexpr usize operator*() const noexcept { return i; }
    constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
  };
  const itr f, l;
  constexpr rep(const usize f, const usize l) noexcept
      : f(std::min(f, l)), l(l) {}
  constexpr auto begin() const noexcept { return f; }
  constexpr auto end() const noexcept { return l; }
};
struct revrep {
  struct itr {
    usize i;
    constexpr itr(const usize i) noexcept : i(i) {}
    void operator++() noexcept { --i; }
    constexpr usize operator*() const noexcept { return i; }
    constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
  };
  const itr f, l;
  constexpr revrep(const usize f, const usize l) noexcept
      : f(l - 1), l(std::min(f, l) - 1) {}
  constexpr auto begin() const noexcept { return f; }
  constexpr auto end() const noexcept { return l; }
};
template <class T> auto md_vec(const usize n, const T &value) {
  return std::vector<T>(n, value);
}
template <class... Args> auto md_vec(const usize n, Args... args) {
  return std::vector<decltype(md_vec(args...))>(n, md_vec(args...));
}
template <class T> constexpr T difference(const T &a, const T &b) noexcept {
  if (a < b) {
    return b - a;
  } else {
    return a - b;
  }
}
template <class T> void chmin(T &a, const T &b) noexcept {
  if (b < a) {
    a = b;
  }
}
template <class T> void chmax(T &a, const T &b) noexcept {
  if (a < b) {
    a = b;
  }
}
template <class F> class fix_point : private F {
public:
  explicit constexpr fix_point(F &&f) : F(std::forward<F>(f)) {}

  template <class... Args>
  constexpr decltype(auto) operator()(Args &&... args) const {
    return F::operator()(*this, std::forward<Args>(args)...);
  }
};
template <class F> constexpr decltype(auto) make_fix(F &&f) {
  return fix_point<F>(std::forward<F>(f));
}
template <class T> T scan() {
  T ret;
  std::cin >> ret;
  return ret;
}

} // namespace n91
#include <cassert>
#include <cstddef>
#include <vector>

template <class Monoid> class segment_tree {
public:
  using T = typename Monoid::value_type;
  using size_t = std::size_t;

private:
  std::vector<T> tree;

  template <class F>
  size_t search_subtree(size_t index, const F f, T fold_l) const {
    while (index < size()) {
      const T temp = Monoid::operation(fold_l, tree[index * 2]);
      if (!f(temp)) {
        index = index * 2;
      } else {
        fold_l = temp;
        index = index * 2 + 1;
      }
    }
    return index - size();
  }

public:
  segment_tree() = default;
  explicit segment_tree(const size_t n) : tree(n * 2, Monoid::identity) {}

  size_t size() const noexcept { return tree.size() / 2; }

  T fold(size_t first, size_t last) const {
    assert(first <= last);
    assert(last <= size());
    first += size();
    last += size();
    T fold_l = Monoid::identity;
    T fold_r = Monoid::identity;
    while (first != last) {
      if (first % 2 != 0) {
        fold_l = Monoid::operation(fold_l, tree[first]);
        first += 1;
      }
      first /= 2;
      if (last % 2 != 0) {
        last -= 1;
        fold_r = Monoid::operation(tree[last], fold_r);
      }
      last /= 2;
    }
    return Monoid::operation(fold_l, fold_r);
  }
  template <class F> size_t search(size_t first, size_t last, const F f) const {
    assert(first <= last);
    assert(last <= size());
    first += size();
    last += size();
    const size_t last_cp = last;
    size_t shift = 0;
    T fold_l = Monoid::identity;
    while (first != last) {
      if (first % 2 != 0) {
        const T temp = Monoid::operation(fold_l, tree[first]);
        if (!f(temp))
          return search_subtree(first, f, fold_l);
        fold_l = temp;
        first += 1;
      }
      first /= 2;
      last /= 2;
      shift += 1;
    }
    while (shift != 0) {
      shift -= 1;
      last = last_cp >> shift;
      if (last % 2 != 0) {
        last -= 1;
        const T temp = Monoid::operation(fold_l, tree[last]);
        if (!f(temp))
          return search_subtree(last, f, fold_l);
        fold_l = temp;
      }
    }
    return last_cp - size();
  }

  void update(size_t index, const T x) {
    assert(index < size());
    index += size();
    tree[index] = x;
    while (index != 1) {
      index /= 2;
      tree[index] = Monoid::operation(tree[index * 2], tree[index * 2 + 1]);
    }
  }
};
#include <algorithm>
#include <limits>

template <class T> class max_monoid {
public:
  using value_type = T;
  static constexpr T operation(const T &x, const T &y) noexcept {
    return std::max(x, y);
  }
  static constexpr T identity = std::numeric_limits<T>::lowest();
};
template <class T> constexpr T max_monoid<T>::identity;
#include <algorithm>
#include <iostream>
#include <map>
#include <tuple>
#include <utility>
#include <vector>

namespace n91 {

void main_() {
  /*
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
  //*/
  const usize n = scan<usize>();
  const i32 v = scan<i32>();
  const i32 xl = scan<i32>();
  const i32 xr = scan<i32>();
  struct mogu_t {
    i32 x;
    i32 y;
    u32 p;
    bool f;
  };
  std::vector<mogu_t> ms(n);
  std::map<i32, usize> mp;
  for (auto &e : ms) {
    e.f = false;
    const i32 x = scan<i32>();
    const i32 t = scan<i32>();
    const u32 p = scan<u32>();
    e.x = -t * v + x;
    e.y = -t * v - x;
    e.p = p;
    mp[e.y];
  }
  ms.push_back({xl, -xl, 0, true});
  ms.push_back({xr, -xr, 0, true});
  mp[-xl];
  mp[-xr];
  {
    usize c = 0;
    for (auto &e : mp)
      e.second = c++;
  }
  std::sort(ms.begin(), ms.end(), [](auto l, auto r) {
    return std::tie(l.x, l.y) < std::tie(r.x, r.y);
  });
  using seg_t = segment_tree<max_monoid<u32>>;
  const usize m = mp.size();
  std::vector<seg_t> dp(m, seg_t(m));
  usize ph = 0;
  for (const auto &e : ms) {
    if (e.f) {
      ph += 1;
      continue;
    }
    const usize k = mp[e.y];
    if (ph <= 1)
      dp[k].update(k, dp[k].fold(0, k + 1) + e.p);
    for (const usize i : rep(0, m)) {
      if (i == k)
        continue;
      const u32 v = dp[i].fold(0, k + 1) + e.p;
      if (ph <= 1)
        dp[i].update(k, v);
      if (ph <= 0)
        dp[k].update(i, v);
    }
    /*
    std::cout << "\n";
    for (const auto i : rep(0, m)) {
      for (const auto j : rep(0, m)) {
        std::cout << dp[i].fold(j, j + 1) << " ";
      }
      std::cout << "\n";
    }
    */
  }
  u32 ans = 0;
  for (const auto i : rep(0, mp[-xl] + 1)) {
    chmax(ans, dp[i].fold(0, mp[-xr] + 1));
  }
  std::cout << ans << std::endl;
}

} // namespace n91

int main() {
  n91::main_();
  return 0;
}



Measured memory_bytes: 144140