#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
//#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;

#define HUGE_NUM 10000000000
#define NUM 6050

typedef pair<ll,ll> P;

struct Edge{
    Edge(int arg_to,ll arg_capacity,ll arg_cost,int arg_rev_index){
        to = arg_to;
        capacity = arg_capacity;
        cost = arg_cost;
        rev_index = arg_rev_index;
    }

    int to,rev_index;
    ll capacity,cost;
};

struct Info{
    void set(int arg_x,int arg_appear_time,ll arg_value){
        x = arg_x;
        appear_time = arg_appear_time;
        value = arg_value;
    }
    bool operator<(const struct Info & arg) const{
        return appear_time < arg.appear_time;
    }
    int x,appear_time;
    ll value;
};

int N,speed;
int V;
vector<Edge> G[NUM];
ll h[NUM];
ll dist[NUM];
int pre_node[NUM],pre_edge[NUM];
int index_IN[NUM],index_OUT[NUM];
int in_num[NUM];
bool visited[NUM];
Info LEFT,RIGHT,info[NUM];


void add_edge(int from,int to,ll capacity,ll cost){
    G[from].push_back(Edge(to,capacity,cost,G[to].size()));
    G[to].push_back(Edge(from,0,-cost,G[from].size()-1));
}


ll min_cost_flow(int source,int sink,ll flow){
    ll ret = 0;
    for(int i = 0; i < V; i++){
        h[i] = HUGE_NUM;
        in_num[i] = 0;
    }

    h[source] = 0;

    for(int i = 0; i < V; i++){
        for(ll k = 0; k < G[i].size(); k++){
            if(G[i][k].capacity == 0)continue;

            in_num[G[i][k].to]++;
        }
    }

    queue<int> TOPO;
    for(int i = 0; i < V; i++){

        if(in_num[i] == 0){
            TOPO.push(i);
        }
    }

    int tmp_node;

    while(!TOPO.empty()){
        tmp_node = TOPO.front();
        TOPO.pop();

        for(int i = 0; i < G[tmp_node].size(); i++){
            if(G[tmp_node][i].capacity <= 0)continue;

            h[G[tmp_node][i].to] = min(h[G[tmp_node][i].to],h[tmp_node]+G[tmp_node][i].cost);

            in_num[G[tmp_node][i].to]--;
            if(in_num[G[tmp_node][i].to] == 0){
                TOPO.push(G[tmp_node][i].to);
            }
        }
    }

    while(flow > 0){

        for(int i = 0; i < V; i++)dist[i] = HUGE_NUM;
        dist[source] = 0;

        for(int i = 0; i < V; i++)visited[i] = false;

        while(true){

            tmp_node = -1;

            for(ll i = 0; i < V; i++){
                if(visited[i] == false && (tmp_node == -1 || dist[tmp_node] > dist[i])){
                    tmp_node = i;
                }
            }

            if(tmp_node == -1)break;

            visited[tmp_node] = true;

            for(int i = 0; i < G[tmp_node].size(); i++){
                Edge &e = G[tmp_node][i];
                if(e.capacity == 0 || dist[e.to] <= dist[tmp_node]+e.cost+h[tmp_node]-h[e.to])continue;
                dist[e.to] = dist[tmp_node]+e.cost+h[tmp_node]-h[e.to];
                pre_node[e.to] = tmp_node;
                pre_edge[e.to] = i;

            }
        }

        if(dist[sink] == HUGE_NUM){
            return -1;
        }

        for(int node_id = 0; node_id < V; node_id++)h[node_id] += dist[node_id];

        ll tmp_flow = flow;

        for(int node_id = sink; node_id != source; node_id = pre_node[node_id]){

            tmp_flow = min(tmp_flow,G[pre_node[node_id]][pre_edge[node_id]].capacity);
        }
        flow -= tmp_flow;
        ret += tmp_flow*h[sink];

        for(int node_id = sink; node_id != source; node_id = pre_node[node_id]){
            Edge &e = G[pre_node[node_id]][pre_edge[node_id]];
            e.capacity -= tmp_flow;
            G[node_id][e.rev_index].capacity += tmp_flow;
        }
    }
    return ret;
}


int main(){

    scanf("%d %d %d %d",&N,&speed,&LEFT.x,&RIGHT.x);

    for(int i = 0; i < N; i++){

        scanf("%d %d %d",&info[i].x,&info[i].appear_time,&info[i].value);
    }
    sort(info,info+N);

    int source = 0,sink = 1,first_left = 2,first_right = 3,index = 4;

    for(int i = 0; i < N; i++){

        index_IN[i] = index++;
    }
    for(int i = 0; i < N; i++){

        index_OUT[i] = index++;
        add_edge(index_OUT[i],sink,1,0);
    }
    for(ll i = 0; i < N; i++){

        add_edge(index_IN[i],index_OUT[i],1,-info[i].value);
    }

     add_edge(source,first_left,1,0);
    add_edge(first_left,sink,1,0);

    for(int i = 0; i < N; i++){

        if(abs(info[i].x-LEFT.x) <= speed*info[i].appear_time){

            add_edge(first_left,index_IN[i],1,0);
        }
    }

    add_edge(source,first_right,1,0);
    add_edge(first_right,sink,1,0);

    for(int i = 0; i < N; i++){

        if(abs(info[i].x-RIGHT.x) <= speed*info[i].appear_time){

            add_edge(first_right,index_IN[i],1,0);
        }
    }

    for(int i = 0; i < N-1; i++){
        for(int k = i+1; k < N; k++){
            if(abs(info[k].x-info[i].x) <= speed*(info[k].appear_time-info[i].appear_time)){

                add_edge(index_OUT[i],index_IN[k],1,0);
            }
        }
    }

    add_edge(source,sink,2,0);

    V = index;

    ll ans = min_cost_flow(source,sink,2);

    printf("%lld\n",-ans);

    return 0;
}



Measured memory_bytes: 256348