#include <bits/stdc++.h>
#define MAX 500005
#define MOD (ll)(1e9+7)
#define INF 2100000000
using namespace std;
//typedef long long ll;
typedef complex<double> cpx;
int N, M, Q, U, D, S;
int dp[MAX][2];
int seg[4 * MAX][2];
struct Market {
int t, l, c;
bool operator < (Market& m) {
if(t != m.t) return t < m.t;
return l < m.l;
}
} arr[MAX];
void init(int str, int ed, int node) {
if(str == ed) {
seg[node][0] = seg[node][1] = -INF;
return;
}
int mid = str + ed >> 1;
init(str, mid, node << 1); init(mid + 1, ed, node << 1 | 1);
seg[node][0] = seg[node][1] = -INF;
}
void update(int str, int ed, int idx, int type, int node) {
if(str == ed) {
seg[node][0] = max(seg[node][0], dp[idx][type] + D * idx);
seg[node][1] = max(seg[node][1], dp[idx][type] - U * idx);
return;
}
int mid = str + ed >> 1;
if(idx <= mid) update(str, mid, idx, type, node << 1);
else update(mid + 1, ed, idx, type, node << 1 | 1);
seg[node][0] = max(seg[node << 1][0], seg[node << 1 | 1][0]);
seg[node][1] = max(seg[node << 1][1], seg[node << 1 | 1][1]);
}
int query(int str, int ed, int left, int right, int type, int node) {
if(str > right || ed < left) return -INF;
if(left <= str && ed <= right) return seg[node][type];
int mid = str + ed >> 1;
return max(query(str, mid, left, right, type, node << 1), query(mid + 1, ed, left, right, type, node << 1 | 1));
}
void solve(int type) {
dp[S][type] = 0;
init(1, M, 1);
update(1, M, S, type, 1);
int prv = 1;
for(int i = 1; i <= N; ++i) {
int j = arr[i].l;
dp[j][type] = max(dp[j][type], arr[i].c - D * arr[i].l + query(1, M, 1, arr[i].l, 0, 1));
dp[j][type] = max(dp[j][type], arr[i].c + U * arr[i].l + query(1, M, arr[i].l, M, 1, 1));
update(1, M, arr[i].l, type, 1);
if(i == N || arr[i + 1].t == arr[i].t) continue;
for(int k = prv; k <= i; ++k) {
//dp[arr[k].l][type] = max(dp[arr[k].l][type], dp[arr[k].l][type]);
update(1, M, arr[k].l, !type, 1);
}
prv = i + 1;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> U >> D >> S; M = S;
for(int i = 1; i <= N; ++i) {
cin >> arr[i].t >> arr[i].l >> arr[i].c;
M = max(M, arr[i].l);
}
arr[0] = {-1, S, 0}; arr[++N] = {INF, S, 0};
for(int i = 0; i <= M; ++i) dp[i][0] = dp[i][1] = -INF;
sort(arr, arr + N); solve(0);
sort(arr, arr + N, [&](auto a, auto b) {
if(a.t != b.t) return a.t < b.t;
return a.l > b.l;
});
solve(1);
// for(int i = 0; i <= N; ++i) {
// cout << dp[arr[i].l][1] << ' ';
// }
cout << max(dp[S][0], dp[S][1]);
return 0;
}
