from collections import deque
class FoldableDeque:
    def __init__(self,op,e)->None:
        self.op=op
        self.e=e
        self.left=deque()
        self.leftop=deque([e()])
        self.right=deque()
        self.rightop=deque([e()])
    
    def append(self,v:any)->None:
        self.right.append(v)
        self.rightop.append(self.op(self.rightop[-1],v))

    def appendleft(self,v:any)->None:
        self.left.append(v)
        self.leftop.append(self.op(v,self.leftop[-1]))
    
    def pop(self)->any:
        if len(self.right)==0:
            nl=[]
            while len(self.left)>0:
                nl.append(self.popleft())
            self.leftop=deque([self.e()])
            half=len(nl)//2
            for i in nl[half:]:
                self.append(i)
            for i in nl[:half][::-1]:
                self.appendleft(i)
        self.rightop.pop()
        return self.right.pop()
    
    def popleft(self)->any:
        if len(self.left)==0:
            nr=[]
            while len(self.right)>0:
                nr.append(self.pop())
            self.rightop=deque([self.e()])
            half=len(nr)//2
            for i in nr[half:]:
                self.appendleft(i)
            for i in nr[:half][::-1]:
                self.append(i)
        self.leftop.pop()
        return self.left.pop()

    def get_all(self):
        return self.op(self.leftop[-1],self.rightop[-1])
    
    def __len__(self)->int:
        return len(self.left)+len(self.right)

    def __str__(self)->str:
        return str(list(self.left)[::-1])+str(list(self.right))

class FoldableQueue(FoldableDeque):
    def pop(self):
        assert False

    def popleft(self)->any:
        if len(self.left)==0:
            for i in reversed(self.right):
                self.appendleft(i)
            self.right=deque()
            self.rightop=deque([self.e()])
        self.leftop.pop()
        return self.left.pop()

N,S,H=map(int,input().split())
segs=[(-(1<<60),-(1<<60),0)]+[tuple(map(int,input().split())) for i in range(N)]+[(1<<60,1<<60,0)]
segs=[(x,y,z) for x,y,z in segs if y-x<=S]
N=len(segs)
last_sleep=[-1]*N
pnt=0
for i in range(1,N):
    while segs[i][0]-segs[pnt+1][1]>=H:
        pnt+=1
    last_sleep[i]=pnt
last_listen=[-1]*N
pnt=0
for i in range(1,N):
    while segs[i][1]-segs[pnt][0]>S:
        pnt+=1
    last_listen[i]=pnt
cum=[0]*N
for i in range(1,N):
    cum[i]=cum[i-1]+segs[i][2]
sleep_dp=[0]*N
listen_dp=FoldableQueue(lambda x,y:max(x,y),lambda:-(1<<60))
for i in range(1,N):
    listen_dp.append(sleep_dp[last_sleep[i]]-cum[i-1])
    while len(listen_dp)>i+1-last_listen[i]:
        listen_dp.popleft()
    sleep_dp[i]=max(sleep_dp[i-1],listen_dp.get_all()+cum[i])
print(sleep_dp[-1])