#!/bin/python

import sys

debug = False

def inside(c1,c2):
    return c2[0]<=c1[0]<=c1[2]<=c2[2] and \
    c2[1]<=c1[1]<=c1[3]<=c2[3]
        
    
def cross(c1,c2):
    return c1[2]>=c2[0] and c2[2]>=c1[0] and \
    c1[3]>=c2[1] and c2[3]>=c1[1]
        
def size1(c):
    return c[0]+1==c[2] and c[1]+1==c[3]

def max2(x):
    p=1
    c=0
    while p<x:
        p*=2
        c+=1
    return p

def split(c):
    return (c[0],c[1],(c[0]+c[2])/2,(c[1]+c[3])/2), \
((c[0]+c[2])/2,c[1],c[2],(c[1]+c[3])/2),\
(c[0],(c[1]+c[3])/2,(c[0]+c[2])/2,c[3]),\
((c[0]+c[2])/2,(c[1]+c[3])/2,c[2],c[3])

class Tree(object):
    def __init__(self,coords):
        self.final = True
        self.coords=coords
        self.children = []
        self.maxval = -sys.maxint
        
    def __repr__(self):
        return "{} {} {} ( {} )".format(self.final, self.coords,self.maxval,self.children)
        
    def mx(self,coords):
        if inside(self.coords,coords):
            return self.maxval
        elif not self.final:
            return max(child.mx(coords) for child in self.children if cross(child.coords,coords))
        else:
            return -sys.maxint
        
    def add(self,lat,lon,val):
        if debug: print 'add', lat, lon, self.coords
        if size1(self.coords):
            if self.coords==(lat,lon,lat+1,lon+1):
                self.maxval=max(val,self.maxval)
        else:
            if self.final:
                self.final=False                
                for child_coo in split(self.coords):
                    child = Tree(child_coo)
                    self.children.append(child)
            for child in self.children:
                if inside((lat,lon,lat+1,lon+1),child.coords):
                    self.maxval=max(self.maxval,child.add(lat,lon,val))
        return self.maxval

n,x,y = raw_input().strip().split(' ')
n,x,y = [int(n),int(x),int(y)]
cities = []
maxlat=None
maxlon=None
for a0 in xrange(n):
    latitude,longitude,height,points = raw_input().strip().split(' ')
    latitude,longitude,height,points = [int(latitude),int(longitude),int(height),int(points)]
    maxlat=max(maxlat,latitude)
    maxlon=max(maxlon,longitude)
    cities.append((latitude,longitude,height,points))
cities.sort(key=lambda x:x[2])
best = 0
root = Tree((0,0,max2(maxlat+1),max2(maxlon+1)))

for city in cities:
    if debug: print root
    latitude,longitude,height,points = city
    mx = root.mx((latitude-x,longitude-y,latitude+x,longitude+y))
    if debug: print mx, city
    mx = max(0,mx)
    if best < mx+points:
        best = mx+points
    root.add(latitude,longitude,mx+points)

print best