import sys
from collections import deque

class Edge:
    def __init__(self, to, rev, cap):
        self.to = to
        self.rev = rev
        self.cap = cap

class Dinic:
    def __init__(self, n):
        self.size = n
        self.graph = [[] for _ in range(n)]
    
    def add_edge(self, fr, to, cap):
        forward = Edge(to, len(self.graph[to]), cap)
        backward = Edge(fr, len(self.graph[fr]), 0)
        self.graph[fr].append(forward)
        self.graph[to].append(backward)
    
    def bfs_level(self, s, t, level):
        q = deque([s])
        level[:] = [-1]*self.size
        level[s] = 0
        while q:
            v = q.popleft()
            if v == t:
                return
            for edge in self.graph[v]:
                if edge.cap > 0 and level[edge.to] == -1:
                    level[edge.to] = level[v]+1
                    q.append(edge.to)
    
    def dfs_flow(self, v, t, upTo, iter_, level):
        if v == t:
            return upTo
        for i in range(iter_[v], len(self.graph[v])):
            edge = self.graph[v][i]
            if edge.cap > 0 and level[v] < level[edge.to]:
                d = self.dfs_flow(edge.to, t, min(upTo, edge.cap), iter_, level)
                if d > 0:
                    edge.cap -= d
                    self.graph[edge.to][edge.rev].cap += d
                    return d
            iter_[v] += 1
        return 0
    
    def max_flow(self, s, t):
        flow = 0
        level = [-1]*self.size
        while True:
            self.bfs_level(s, t, level)
            if level[t] == -1:
                return flow
            iter_ = [0]*self.size
            while True:
                f = self.dfs_flow(s, t, float('inf'), iter_, level)
                if f == 0:
                    break
                flow += f
            level = [-1]*self.size

def main():
    input = sys.stdin.read().split()
    idx = 0
    N = int(input[idx]); idx += 1
    M = int(input[idx]); idx += 1
    d = int(input[idx]); idx += 1
    flights = []
    for _ in range(M):
        u = int(input[idx]); idx += 1
        v = int(input[idx]); idx += 1
        p = int(input[idx]); idx += 1
        q = int(input[idx]); idx += 1
        w = int(input[idx]); idx += 1
        flights.append((u, v, p, q, w))
    
    size = 2 * M + 2
    source = 2 * M
    sink = 2 * M + 1
    dinic = Dinic(size)
    
    for i in range(M):
        u, v, p, q, w = flights[i]
        in_node = 2 * i
        out_node = 2 * i + 1
        dinic.add_edge(in_node, out_node, w)
        if u == 1 and p >= 0:
            dinic.add_edge(source, in_node, 10**18)
        if v == N:
            dinic.add_edge(out_node, sink, 10**18)
    
    for i in range(M):
        _, v_i, _, q_i, _ = flights[i]
        for j in range(M):
            u_j, _, p_j, _, _ = flights[j]
            if i != j and v_i == u_j and (q_i + d) <= p_j:
                dinic.add_edge(2 * i + 1, 2 * j, 10**18)
    
    print(dinic.max_flow(source, sink))

if __name__ == '__main__':
    main()