using System;
using System.Collections.Generic;
using System.Text;

public class GetToTheTop
{
    private Stair[] stairs;
    private bool[,] compAdj;

    private class Stair : IComparable<Stair>
    {
        public int X, Y, Len, Sweets;

        public Stair(int x, int y, int len, int sweets)
        {
            X = x;
            Y = y;
            Len = len;
            Sweets = sweets;
        }

        public int CompareTo(Stair other)
        {
            if (Y != other.Y)
                return Y.CompareTo(other.Y);
            return X.CompareTo(other.X);
        }

        public int EndX { get { return X + Len; } }

        public bool CanReach(Stair other, int maxDist)
        {
            if (other.Y < Y)
                return false;
            if (Intersect(X, EndX, other.X, other.EndX))
                return other.Y - Y <= maxDist;
            else
            {
                int ourX, otherX;
                if (other.X > EndX)
                {
                    ourX = EndX;
                    otherX = other.X;
                }
                else
                {
                    ourX = X;
                    otherX = other.EndX;
                }
                return Sqr(ourX - otherX) + Sqr(Y - other.Y) <= Sqr(maxDist);
            }
        }

        private bool Intersect(int a1, int b1, int a2, int b2)
        {
            return !(a2 > b1 || a1 > b2);
        }

        private long Sqr(int x)
        {
            return x * x;
        }
    }

    private class Component
    {
        private List<Stair> stairs = new List<Stair>();
        public int Sweets;
        public int Y;

        public bool Empty { get { return stairs.Count == 0; } }

        public void Add(Stair st)
        {
            stairs.Add(st);
            Sweets += st.Sweets;
            Y = st.Y;
        }

        public bool CanReach(Component other, int maxDist)
        {
            for (int i = 0; i < stairs.Count; i++)
            {
                for (int j = 0; j < other.stairs.Count; j++)
                {
                    if (stairs[i].CanReach(other.stairs[j], maxDist))
                        return true;
                }
            }
            return false;
        }

        public bool Belongs(Stair stair, int maxDist)
        {
            Stair last = stairs[stairs.Count - 1];
            return stairs.Count == 0 || (stair.Y == last.Y && last.EndX + maxDist >= stair.X);
        }
    }

    public int collectSweets(int K, int[] sweets, int[] x, int[] y, int[] stairLength)
    {
        stairs = new Stair[sweets.Length];
        for (int i = 0; i < sweets.Length; i++)
            stairs[i] = new Stair(x[i], y[i], stairLength[i], sweets[i]);
        Array.Sort(stairs);

        Component comp = new Component();
        for (int i = 0; i < stairs.Length; i++)
        {
            if (i > 0 && !comp.Belongs(stairs[i], K))
            {
                components.Add(comp);
                comp = new Component();
            }
            comp.Add(stairs[i]);
        }
        if (!comp.Empty)
            components.Add(comp);

        compAdj = new bool[components.Count,components.Count];
        best = new int[components.Count];
        for (int i = 0; i < best.Length; i++)
            best[i] = -1;

        for (int i = 0; i < components.Count; i++)
        {
            for (int j = i + 1; j < components.Count; j++)
            {
                if (components[i].CanReach(components[j], K))
                    compAdj[i, j] = true;
            }
        }

        int res = 0;
        for (int i = 0; i < components.Count; i++)
        {
            if (components[i].Y <= K)
                res = Math.Max(res, Rec(i));
        }

        return res;
    }

    private int[] best;
    private List<Component> components = new List<Component>();

    private int Rec(int startComp)
    {
        if (best[startComp] != -1)
            return best[startComp];

        int res = 0;
        for (int i = 0; i < components.Count; i++)
        {
            if (compAdj[startComp, i])
                res = Math.Max(res, Rec(i));
        }
        return best[startComp] = res + components[startComp].Sweets;
    }
}