/*AMETHYSTS*/
#pragma comment(linker, "/STACK:1000000000")
#include <cstdio>
#include <iostream>
#include <ctime>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <set>
#include <cstdlib>
#include <ctime>
#include <cassert>
#include <bitset>
#include <fstream>
#include <deque>
#include <stack>
#include <climits>
#include <string>
#include <queue>
#include <memory.h>
#include <map>
#include <unordered_map>

#define ll long long
#define ld double
#define pii pair <ll, ll>
#define mp make_pair

using namespace std;

const int maxn = (int)2e5 + 10;

int h[maxn];
int a[maxn];
int b[maxn];
int c[maxn];
int num[maxn];

bool cmp(int a, int b) {
	return h[a] < h[b];
}

vector <int> g[maxn];
vector <int> f[4 * maxn];
vector <ll> tr[4 * maxn];

inline void build(int it, int l, int r) {
	if (l == r) {
		tr[it].assign(g[l].size() * 4, 0);
		sort(g[l].begin(), g[l].end());
		f[it] = g[l];
	} else {
		int m = (l + r) >> 1;

		build((it << 1), l, m);
		build((it << 1) + 1, m + 1, r);

		f[it].resize(f[(it << 1)].size() + f[(it << 1) + 1].size());

		merge(f[(it << 1)].begin(), f[(it << 1)].end(), f[(it << 1) + 1].begin(), f[(it << 1) + 1].end(), f[it].begin());

		tr[it].assign(f[it].size() * 4, 0);
	}
}

inline void change1(int it, int it1, int l, int r, int pos, ll x) {
	if (l == r) {
		tr[it][it1] = max(x, tr[it][it1]);
	} else {
		int m = (l + r) >> 1;

		if (pos <= m) {
			change1(it, (it1 << 1), l, m, pos, x);
		} else {
			change1(it, (it1 << 1) + 1, m + 1, r, pos, x);
		}

		tr[it][it1] = max(tr[it][(it1 << 1)], tr[it][(it1 << 1) + 1]);
	}
}

inline void change(int it, int l, int r, int pos, int pos1, ll x) {
	change1(it, 1, 0, (int)f[it].size() - 1, lower_bound(f[it].begin(), f[it].end(), pos1) - f[it].begin(), x);

	if (l == r) {
		return;
	}

	int m = (l + r) >> 1;

	if (pos <= m) {
		change((it << 1), l, m, pos, pos1, x);
	} else {
		change((it << 1) + 1, m + 1, r, pos, pos1, x);
	}
}

inline ll go(int it, int it1, int l, int r, int lm, int rm) {
	if (lm > rm) {
		return 0;
	}

	if (l == lm && r == rm) {
		return tr[it][it1];
	} else {
		int m = (l + r) >> 1;

		if (rm <= m) {
			return go(it, (it1 << 1), l, m, lm, rm);
		} else if (lm > m) {
			return go(it, (it1 << 1) + 1, m + 1, r, lm, rm);
		} else {
			return max(go(it, (it1 << 1), l, m, lm, m), go(it, (it1 << 1) + 1, m + 1, r, m + 1, rm));
		}
	}
}

inline ll go(int it, int l, int r, int lm, int rm, int lm1, int rm1) {
	if (l == lm && r == rm) {
		lm1 = lower_bound(f[it].begin(), f[it].end(), lm1) - f[it].begin();
		rm1 = upper_bound(f[it].begin() + lm1, f[it].end(), rm1) - f[it].begin() - 1;
		return go(it, 1, 0, (int)f[it].size() - 1, lm1, rm1);
	} else {
		int m = (l + r) >> 1;

		if (rm <= m) {
			return go((it << 1), l, m, lm, rm, lm1, rm1);
		} else if (lm > m) {
			return go((it << 1) + 1, m + 1, r, lm, rm, lm1, rm1);
		} else {
			return max(go((it << 1), l, m, lm, m, lm1, rm1), go((it << 1) + 1, m + 1, r, m + 1, rm, lm1, rm1));
		}
	}
}

int main() {
	int n, x, y;

	cin >> n >> x >> y;

	for (int i = 0; i < n; i++) {
		scanf("%d %d %d %d", &a[i], &b[i], &h[i], &c[i]);
		num[i] = i;
		g[a[i]].push_back(b[i]);
	}

	build(1, 0, maxn - 1);

	sort(num, num + n, cmp);

	ll ans = 0;

	for (int ti = n - 1; ti >= 0; ti--) {
		int i = num[ti];

		ll res = c[i] + max(0ll, go(1, 0, maxn - 1, max(a[i] - x, 0), min(a[i] + x, maxn - 1), b[i] - y, b[i] + y));

		ans = max(ans, res);

		change(1, 0, maxn - 1, a[i], b[i], res);
	}

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