#include <iostream>
#include <vector>
#include <cstring>
#include <string>
#include <algorithm>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <functional>
#include <queue>
using namespace std;
typedef pair<int, int> Pii;
struct edge { int to, cap, cost, rev; };
const int MAX_V = 6100, INF = 1e9;
int V;
vector<edge> G[MAX_V];
int h[MAX_V];
int dist[MAX_V];
int prevv[MAX_V], preve[MAX_V];
vector<int> top;
void add_edge(int from, int to, int cap, int cost) {
	//  printf("%d->%d  cap=%d,cost=%d\n",from,to,cap,cost);
	edge e1 = { to, cap, cost, (int)G[to].size() }, e2 = { from, 0, -cost, (int)G[from].size() };
	G[from].push_back(e1);
	G[to].push_back(e2);
}
int min_cost_flow(int s, int t, int f) {
	int res = 0;
	fill(h, h + V, 0);
	for(int i = 0; i < V; i++) {
		int v = top[i];
		for(int j = 0; j < G[v].size(); j++) {
			edge &e = G[v][j];
			if(e.cap == 0) continue;
			int u = e.to;
			h[u] = min(h[u], h[v] + e.cost);
		}
	}
	//  rep(i,V) printf("h[%d]=%d\n",i,h[i]);
	while(f > 0) {
		priority_queue< Pii, vector<Pii>, greater<Pii> > que;
		fill(dist, dist + V, INF);
		dist[s] = 0;
		que.push(Pii(0, s));
		while(!que.empty()) {
			Pii p = que.top();
			que.pop();
			int v = p.second;
			if(dist[v]<p.first) continue;
			for(int i = 0; i < G[v].size(); i++) {
				edge &e = G[v][i];
				if(e.cap > 0 && dist[e.to]>dist[v] + e.cost + h[v] - h[e.to]) {
					dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
					prevv[e.to] = v;
					preve[e.to] = i;
					que.push(Pii(dist[e.to], e.to));
				}
			}
		}
		if(dist[t] == INF) return -1;
		for(int v = 0; v < V; v++) h[v] += dist[v];
		int d = f;
		for(int v = t; v != s; v = prevv[v]) {
			d = min(d, G[prevv[v]][preve[v]].cap);
		}
		f -= d;
		res += d*h[t];
		for(int v = t; v != s; v = prevv[v]) {
			edge &e = G[prevv[v]][preve[v]];
			e.cap -= d;
			G[v][e.rev].cap += d;
		}
	}
	return res;
}


int X[3000];
int Time[3000];
int P[3000];

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);

	int N, speed, Xl, Xr;
	cin >> N >> speed >> Xl >> Xr;

	for(int i = 0; i < N; i++) {
		cin >> X[i] >> Time[i] >> P[i];
	}
	V = 2 * N + 4;
	int left = 2 * N, right = left + 1, S = right + 1, T = S + 1;
	vector<int> in(N), out(N);
	for(int i = 0; i < N; i++) {
		in[i] = 2 * i;
		out[i] = in[i] + 1;
	}
	for(int i = 0; i < N; i++) {
		for(int j = 0; j < N; j++) {
			if(i == j || Time[i] > Time[j]) continue;
			if(abs(Time[i] - Time[j]) * speed >= abs(X[i] - X[j])) {
				add_edge(out[i], in[j], 2, 0);
			}
		}
		add_edge(out[i], T, 1, 0);
		add_edge(in[i], out[i], 1, -P[i]);
		if(abs(Xl - X[i]) <= speed * Time[i]) {
			add_edge(left, in[i], 1, 0);
		}
		if(abs(Xr - X[i]) <= speed * Time[i]) {
			add_edge(right, in[i], 1, 0);
		}
	}
	add_edge(S, left, 1, 0);
	add_edge(S, right, 1, 0);
	add_edge(left, T, 1, 0);
	add_edge(right, T, 1, 0);

	vector<Pii> ids;
	for(int i = 0; i < N; i++) {
		ids.push_back(Pii(Time[i] * 2, in[i]));
		ids.push_back(Pii(Time[i] * 2 + 1, out[i]));
	}
	sort(ids.begin(), ids.end());

	top.push_back(S);
	top.push_back(left);
	top.push_back(right);
	for(int i = 0; i < ids.size(); i++) {
		top.push_back(ids[i].second);
	}
	top.push_back(T);
	assert(V == top.size());
	cout << -min_cost_flow(S, T, 2) << endl;
}