import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Graph g = new Graph();
        int n = in.nextInt();
        int x = in.nextInt();
        int y = in.nextInt();
        List<Node> nodes = new ArrayList<>();
        for(int a0 = 0; a0 < n; a0++){
            int la = in.nextInt();
            int l = in.nextInt();
            int h = in.nextInt();
            int p = in.nextInt();
            nodes.add(new Node(la,l,h,p));
        }
        g.buildGraph(nodes, 1,1);
    g.maxPoints();
    }
    private static class Graph{
    Map<Integer, List<Node>> adjList;
    Map<Integer, Node>  nameMap;

    public Graph() {
      this.adjList = new HashMap<>();
      this.nameMap = new HashMap<>();
    }

    private void addVertex(Node n, int x, int y){
      for(int i =0;i<n.name;i++){
        Node src = nameMap.get(i);
        if(Math.abs(src.lat-n.lat) <= x && Math.abs(src.lng-n.lng) <=y){
          List<Node> edges = this.adjList.getOrDefault(i, new ArrayList<>());
          edges.add(n);
          this.adjList.put(i, edges);
        }
      }
    }

    private void buildGraph(List<Node> nodes, int x , int y){
      Collections.sort(nodes);
      int i =0;
      List<Node> newNodes = new ArrayList<>();
      for(final Node node:nodes){
        node.name =i;
        newNodes.add(node);
        this.nameMap.put(i, node);
        i++;
      }
      for(final Node node:newNodes){
        this.addVertex(node, x, y);
      }

    }

    private void maxPoints(){
      int size = this.nameMap.size();
      Map<Integer, Boolean> visited = new HashMap<>();
      Queue queue = new Queue();
      long maxPoint = 0;
      long currPoint = 0;

      while (size>visited.size()) {

        for(int i =0;i<size;i++){
          if(!visited.getOrDefault(i, false)){
            queue.enqueue(i);
            break;
          }
        }
        while (!queue.isEmpty()) {
          int item = (int) queue.dequeue();
          if (visited.getOrDefault(item, false)) {
            continue;
          }
          visited.put(item, true);
          currPoint += nameMap.get(item).p;

          for (final Node node : adjList.getOrDefault(item, new ArrayList<>())) {
            queue.enqueue(node.name);
          }
        }
        if(maxPoint<currPoint){
          maxPoint = currPoint;
        }
      }
      System.out.println(maxPoint);
    }



  }

  private static class Queue {
    private LinkedList list;


    public Queue() {
      list = new LinkedList();
    }

    public boolean isEmpty()

    {
      return (list.size() == 0);
    }

    public void enqueue(Object item)

    {
      list.add(item);
    }

    public Object dequeue()

    {

      Object item = list.get(0);

      list.remove(0);


      return item;
    }

    public Object peek(){

      return list.get(0);
    }
  }

  private static class Node implements Comparable<Node>{
    int name;
    final int lat;
    final int lng;
    final Integer h;
    final int p;

    public Node(int lat, int lng, int h, int p) {
      this.lat = lat;
      this.lng = lng;
      this.h = h;
      this.p = p;
    }

    @Override
    public int compareTo(Node o) {
      return this.h.compareTo(o.h);
    }
  }
}