#ifndef Yamada
#define Yamada
#include Yamada __FILE__ Yamada

const int maxn = 405;
const int INF = 1e18;


struct Flow { // 0-base
    struct edge {
        int to, cap, flow, rev;
    };
    vector<edge> G[maxn];
    int n, s, t, dis[maxn], cur[maxn], cnt[maxn];
    void init(int _n) {
        n = _n;
        for(int i = 0; i < n + 2; ++i) {
            G[i].clear(); cnt[i] = 0;
        }
    }
    void add_edge(int u, int v, int cap) {
        G[u].eb(edge{v, cap, 0, SZ(G[v])});
        G[v].eb(edge{u, 0, 0, SZ(G[u]) - 1});
    }
    int dfs(int u, int cap) {
        if(u == t || !cap) return cap;
        for(int &i = cur[u]; i < SZ(G[u]); ++i) {
            edge &e = G[u][i];
            if(dis[e.to] == dis[u] + 1 && e.cap != e.flow) {
                int df = dfs(e.to, min(e.cap - e.flow, cap));
                if(df) {
                    e.flow += df, G[e.to][e.rev].flow -= df;
                    return df;
                }
            }
        }
        dis[u] = -1;
        return 0;
    }
    bool bfs() {
        fill_n(dis, n + 3, -1);
        queue<int> q;
        q.push(s), dis[s] = 0;
        while(!q.empty()) {
            int u = q.front();
            q.pop();
            for(edge &e : G[u]) {
                if(!~dis[e.to] && e.flow != e.cap) {
                    q.push(e.to), dis[e.to] = dis[u] + 1;
                }
            }
        }
        return dis[t] != -1;
    }
    int maxflow(int _s, int _t) {
        s = _s, t = _t;
        int flow = 0, df;
        while(bfs()) {
            fill_n(cur, n + 3, 0);
            while((df = dfs(s, INF))) flow += df;
        }
        return flow;
    }
} flowA, flowB;



int sq(int x) { return x * x; }

int a[maxn], b[maxn], x[maxn], y[maxn], o[maxn];
int N, R, G, P;

int dis2(int i, int j) {
    return sq(x[i] - x[j]) + sq(y[i] - y[j]); 
}

void solve() {
    cin >> N >> R >> G >> P;
    for(int i = 0; i < N; ++i) {
        cin >> x[i] >> y[i] >> o[i];
        a[i] = (o[i] <= 90);
        b[i] = (o[i] == 0 || o[i] == 270);
    }
    
    flowA.init(N + 2), flowB.init(N + 2);
    int M = 0;
    for(int i = 0; i < N; ++i) {
        if (a[i] == 1) flowA.add_edge(N, i, P);
        else flowA.add_edge(i, N + 1, P);
        
        if (b[i] == 1) flowB.add_edge(N, i, P);
        else flowB.add_edge(i, N + 1, P);
        
        for(int j = i + 1; j < N; ++j) {
            if(x[i] != x[j] && y[i] != y[j] && dis2(i, j) <= sq(R)) {
                ++M;
                flowA.add_edge(i, j, 2 * G);
                flowA.add_edge(j, i, 2 * G);
                flowB.add_edge(i, j, 2 * G);
                flowB.add_edge(j, i, 2 * G);
            }
        }
    }
    int cut = flowA.maxflow(N, N + 1) + flowB.maxflow(N, N + 1);
    cout << N * P + 2 * G * M - cut << '\n';
}

signed main() {
    IOS();
    int t = 1; // cin >> t;
    for (int i = 1; i <= t; ++i) solve();
    return 0;
}

#else

#ifdef local
#define _GLIBCXX_DEBUG 1
#endif
#include <bits/stdc++.h>
using namespace std;

#define int int64_t
using pii = pair<int, int>;
template <typename T> using MaxHeap = std::priority_queue<T>;
template <typename T> using MinHeap = std::priority_queue<T, vector<T>, greater<T>>;

#define SZ(a) ((int)(a).size())
#define ALL(a) begin(a), end(a)
#define RALL(a) rbegin(a), rend(a)
#define ee emplace
#define eb emplace_back
#define ef emplace_front
#define pb pop_back
#define pf pop_front

#ifdef local
#define IOS() void()
#else
#define IOS() ios_base::sync_with_stdio(0), cin.tie(0);
#endif

template <typename U, typename V> bool chmin(U &u, V v) {return (u > v ? u = v, 1 : 0);}
template <typename U, typename V> bool chmax(U &u, V v) {return (u < v ? u = v, 1 : 0);}

#endif