#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}


template<typename ...Ts>
decltype(auto) zip(vector<Ts>... args){
  vector<decltype(make_tuple(args[0]...))> res;
  int n=min({args.size()...});
  res.reserve(n);
  for(int i=0;i<n;i++) res.emplace_back(args[i]...);
  return res;
}

template<typename V>
V compress(V v){
  sort(v.begin(),v.end());
  v.erase(unique(v.begin(),v.end()),v.end());
  return v;
}
template<typename T>
map<T, int> dict(const vector<T> &v){
  map<T, int> res;
  for(int i=0;i<(int)v.size();i++)
    res[v[i]]=i;
  return res;
}
map<char, int> dict(const string &v){
  return dict(vector<char>(v.begin(),v.end()));
}


template<typename F>
struct FixPoint : F{
  FixPoint(F&& f):F(forward<F>(f)){}
  template<typename... Args>
  decltype(auto) operator()(Args&&... args) const{
    return F::operator()(*this,forward<Args>(args)...);
  }
};
template<typename F>
inline decltype(auto) MFP(F&& f){
  return FixPoint<F>{forward<F>(f)};
}

//INSERT ABOVE HERE
const int MAX = 3030;
int dp[MAX][MAX]={};
int rs[MAX][MAX]={};

const int INF = 1e9;
template<typename T>
struct BIT{
  int n;
  vector<T> bit;
  //1-indexed
  BIT(int n_):n(n_+2),bit(n,-INF){}

  T sum(int i){
    i++;

    T s(-INF);
    for(int x=i;x>0;x-=(x&-x))
      chmax(s,bit[x]);
    return s;
  }

  void add(int i,T a){
    i++;

    for(int x=i;x<n;x+=(x&-x))
      chmax(bit[x],a);
  }
};

signed main(){
  int n,v,xl,xr;
  cin>>n>>v>>xl>>xr;

  vector<int> xs(n),ts(n),ps(n);
  for(int i=0;i<n;i++) cin>>xs[i]>>ts[i]>>ps[i];
  xs.emplace_back(xl);
  ts.emplace_back(0);
  ps.emplace_back(0);
  xs.emplace_back(xr);
  ts.emplace_back(0);
  ps.emplace_back(0);

  xs.emplace_back(0);
  ts.emplace_back(INF);
  ps.emplace_back(0);

  n=xs.size();
  auto zs=zip(ts,xs,ps);
  sort(zs.begin(),zs.end());
  for(int i=0;i<n;i++)
    tie(ts[i],xs[i],ps[i])=zs[i];

  using ll = long long;
  for(int i=0;i<n;i++)
    for(int j=i+1;j<n;j++)
      rs[i][j]=abs(xs[j]-xs[i])<=(ll)v*(ts[j]-ts[i]);

  for(int i=0;i<MAX;i++)
    for(int j=0;j<MAX;j++)
      dp[i][j]=-INF;
  dp[0][1]=0;

  vector<ll> as(n),bs(n);
  for(int i=0;i<n;i++){
    as[i]=-xs[i]+(ll)v*ts[i];
    bs[i]=+xs[i]+(ll)v*ts[i];
  }

  auto da=dict(compress(as));
  auto db=dict(compress(bs));
  vector<int> va(n),vb(n);
  for(int i=0;i<n;i++){
    va[i]=da[as[i]];
    vb[i]=db[bs[i]];
  }

  using P = pair<ll, ll>;
  vector<P> vp,vq;
  for(int l=0;l<n;l++){
    vp.emplace_back(+xs[l],l);
    vq.emplace_back(-xs[l],l);
  }
  sort(vp.begin(),vp.end());
  sort(vq.begin(),vq.end());

  for(int c=1;c<n;c++){
    {
      MFP([&](auto dfs,int l,int r)->void{
            if(l+1==r) return;
            int m=(l+r)>>1;

            dfs(l,m);

            if(r-l<=100){
              for(int a=l;a<m;a++)
                for(int b=m;b<r;b++)
                  if(rs[a][b])
                    chmax(dp[b][c],dp[a][c]+ps[b]);

            }else{
              for(int k=0;k<2;k++){
                vector<P> vp;
                for(int a=l;a<m;a++)
                  vp.emplace_back(k?+xs[a]:-xs[a],a+0);
                for(int b=m;b<r;b++)
                  vp.emplace_back(k?+xs[b]:-xs[b],b+n);
                sort(vp.begin(),vp.end());

                vector<ll> vs;
                for(int i=l;i<r;i++)
                  vs.emplace_back(k?as[i]:bs[i]);
                auto cs=compress(vs);
                vector<ll> ws(r-l);
                for(int i=0;i<r-l;i++)
                  ws[i]=lower_bound(cs.begin(),cs.end(),vs[i])-cs.begin();

                BIT<int> bit(cs.size());
                for(auto p:vp){
                  if(p.second<n){
                    int a=p.second;
                    bit.add(ws[a-l],dp[a][c]);
                  }else{
                    int b=p.second-n;
                    chmax(dp[b][c],bit.sum(ws[b-l])+ps[b]);
                  }
                }
              }
            }

            dfs(m,r);
          })(0,c);
    }


    for(int k=0;k<2;k++){
      auto &vv=k?vp:vq;
      auto &vw=k?va:vb;
      BIT<int> bit(n+10);
      for(auto p:vv){
        if(p.second<c){
          int l=p.second;
          bit.add(vw[l],dp[l][c]);
        }
        if(p.second>c){
          int r=p.second;
          chmax(dp[c][r],bit.sum(vw[r])+ps[r]);
        }
      }
    }
  }

  int ans=0;
  for(int i=0;i<n;i++)
    for(int j=0;j<n;j++)
      chmax(ans,dp[i][j]);

  cout<<ans<<endl;
  return 0;
}



Measured memory_bytes: 67332