#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <set>
#include <map>
#include <cmath>
using namespace std;
typedef long long i64;
typedef long double ld;
typedef pair<i64,i64> P;
#define rep(i,s,e) for(int i = (s);i <= (e);i++)


struct Graph
{
    struct edge
    {
        int to;
        i64 cap;
        i64 rev;
    };

    int n;
    vector<vector<edge>> edges;

    Graph(int N)
    {
        n = N;
        edges.resize(n,vector<edge>());
    }

    int size() const
    {
        return n;
    }

    vector<edge>& operator[](int v)
    {
        return edges[v];
    }
};




struct Dinic
{
    int N;
    vector<int> level;
    vector<int> itr;
    Graph G;

    Dinic(int n) : G(n)
    {
        N = n;
    }

    void add_edge(int from,int to,i64 cap,i64 rev_cap)
    {
        G[from].push_back({to,cap,(int)G[to].size()});
        G[to].push_back({from,rev_cap,(int)G[from].size() - 1});
    }

    bool g_level(int s,int t)
    {
        level.assign(N,-1);
        queue<int> que;
        que.push(s);
        level[s] = 0;
        while(!que.empty())
        {
            int v = que.front();
            que.pop();
            for(auto& e : G[v])
            {
                if(e.cap > 0 && level[e.to] == -1)
                {
                    level[e.to] = level[v] + 1;
                    que.push(e.to);
                }
            }
        }
        return level[t] >= 0;
    }

    int dfs(int v,int t,i64 f)
    {
        if(v == t) return f;

        for(int& i = itr[v];i < G[v].size();i++)
        {
            auto& e = G[v][i];
            if(e.cap > 0 && level[e.to] > level[v])
            {
                i64 mi_f = dfs(e.to,t,min(f,e.cap));
                if(mi_f > 0)
                {
                    e.cap -= mi_f;
                    G[e.to][e.rev].cap += mi_f;
                    return mi_f;
                }
            }
        }
        return 0;
    }

    i64 max_flow(int s,int t)
    {
        i64 result = 0;
        i64 flow;
        while(g_level(s,t))
        {
            itr.assign(N,0);
            while((flow = dfs(s,t,1e9)) > 0) result += flow;
        }
        return result;
    }
};


/*

checked
    http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=2723921#1
*/

int n;
int m;
i64 d;
int u[1010];
int v[1010];
i64 p[1010];
i64 q[1010];
i64 w[1010];

vector<P> memo;

int main()
{
    cin >> n >> m >> d;

    rep(i,0,m - 1)
    {
        cin >> u[i] >> v[i] >> p[i] >> q[i] >> w[i];
        q[i] += d;
        memo.push_back({u[i],p[i]});
        memo.push_back({v[i],q[i]});
    }
    memo.push_back({1,0});
    memo.push_back({n,1e9 + d});
    sort(memo.begin(),memo.end());
    memo.erase(unique(memo.begin(),memo.end()),memo.end());

    Dinic dinic(memo.size());

    rep(i,0,m - 1)
    {
        int a = lower_bound(memo.begin(),memo.end(),(P){u[i],p[i]}) - memo.begin();
        int b = lower_bound(memo.begin(),memo.end(),(P){v[i],q[i]}) - memo.begin();
        dinic.add_edge(a,b,w[i],0);
    }

    rep(i,1,memo.size() - 1)
    {
        if(memo[i - 1].first == memo[i].first)
        {
            dinic.add_edge(i - 1,i,(1LL << 60),0);
        }
    }

    cout << dinic.max_flow(0,memo.size() - 1) << endl;


}