struct Dinic{
    int n, s, t;
    vector<int> level, iter;
    struct edge{
        int to, cap, rev;
        edge(int v, int capacity, int i){
            to = v; cap = capacity; rev = i;
        }
    };
    vector<vector<edge>> adj;
    void init(int _n, int _s, int _t){
        s = _s; t = _t;
        n = _n; adj.assign(n + 1, vector<edge>());
    }
    void add_edge(int from, int to, int cap){
        adj[from].pb(edge(to, cap, adj[to].size()));
        adj[to].pb(edge(from, 0, adj[from].size() - 1));
    }
    void do_bfs(){
        level.assign(n + 1, 0);
        queue<int> bfs; bfs.push(s); level[s] = 1;
        while(bfs.size()){
            int u = bfs.front(); bfs.pop();
            for(auto [v, c, r]:adj[u]){
                if(c && !level[v]){
                    bfs.push(v);
                    level[v] = level[u] + 1;
                    if(v == t) return;
                }
            }
        }
    }
    int dfs(int u, int f){
        if(u == t) return f;
        //next line is an important time saving detail！
        for(int &i = iter[u]; i < adj[u].size(); ++i){ 
            auto &[v, c, r] = adj[u][i];
            if(level[v] != level[u] + 1 || c <= 0) continue;
            int ret = dfs(v, min(f, c));
            if(ret <= 0) continue;
            c -= ret;
            adj[v][r].cap += ret;
            return ret;
        }
        return 0;
    }
    int flow(){
        do_bfs();
        int maxflow = 0, f;
        while(level[t]) {
            iter.assign(n + 1, 0);
            while(f = dfs(s, inf)) maxflow += f;
            do_bfs();
        }
        return maxflow;
    }
}dinic;

#include <bits/stdc++.h>
using namespace std;
#define starburst ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
typedef long long ll;
#define int ll
#define vi vector<int>
#define pb push_back
#define inf 1e18
#define skip(x) if(x)continue;

struct MCF{
    int n, s, t;
    int cost[505], p[505], ep[505];
    bool vis[505], inq[505];
    struct edge{
        int v, ca, co, rev;
        edge(int _v, int _ca, int _co, int _rev): v(_v), ca(_ca), co(_co), rev(_rev){}
    };
    vector<edge> adj[505];
    void init(int _n){
        n = _n; s = 1; t = n;
        for(int i = 1; i <= n; ++i){
            cost[i] = 1e9; inq[i] = vis[i] = p[i] = ep[i] = 0;
        }
    }
    void addedge(int u, int v, int ca, int co){
        adj[u].pb(edge(v, ca, co, (int)adj[v].size()));
        adj[v].pb(edge(u, 0, -co, (int)adj[u].size() - 1));
    }
    int flow(){
        init(n);
        cost[s] = 0;
        queue<int> bfs; bfs.push(s);
        int flow = inf;
        while(bfs.size()){
            int u = bfs.front(); bfs.pop();
            inq[u] = 0; vis[u] = 1;
            for(int i = 0; i < adj[u].size(); ++i){
                edge e = adj[u][i]; int v = e.v;
                if(e.ca != 0 && cost[u] + e.co < cost[v]){
                    p[v] = u;
                    ep[v] = i;
                    cost[v] = cost[u] + e.co;
                    if(!inq[v]){
                        inq[v] = 1;
                        bfs.push(v);
                    }
                }
            }
        }
        if(vis[t] == 0) return 0;
        for(int u = t; u != s; u = p[u]){
            flow = min(flow, adj[p[u]][ep[u]].ca);
        }
        for(int u = t; u != s; u = p[u]){
            adj[p[u]][ep[u]].ca -= flow;
            adj[u][adj[p[u]][ep[u]].rev].ca += flow;
        }
        return flow;
    }
}mcmf;

void solve(){
    int n, m, k, ans = 0; cin >> n >> m >> k;
    mcmf.init(n);
    for(int i = 1; i <= m; ++i){
        int u, v, cap, cost;
        cin >> u >> v >> cap >> cost;
        mcmf.addedge(u, v, cap, cost);
    }
    while(k > 0){
        int flow = mcmf.flow();
        if(mcmf.vis[n] == 0) {
            ans = -1;
            break;
        }
        ans += min(flow, k) * mcmf.cost[n];
        k -= flow;
    }
    cout << ans;
}

signed main(){
    starburst
    int t = 1; //cin >> t;
    while(t--) solve();
}