#include <iostream>


#define BELLMANFORD // O(F|V|^2)
//#define DIJKSTRA    // O(F|E|log|V|)

using namespace std;

#include <utility>
#include <vector>
#include <queue>
#include <cassert>

typedef pair<int, int> P;
class MinCostFlow {
#define MAX_V 10001
private:
  const int INF = 1e9 + 10;
  struct Edge {
    int to, cap, cost, rev;
    Edge(int to, int cap, int cost, int rev):
      to(to), cap(cap), cost(cost), rev(rev) { }
  };
  int V;
  vector<Edge> G[MAX_V];
  int h[MAX_V];
  int dist[MAX_V];
  int prevv[MAX_V], preve[MAX_V];

public:
  MinCostFlow(int V): V(V) { }

  void AddEdge(int from, int to, int cap, int cost) {
    G[from].push_back(Edge(to, cap, cost, G[to].size()));
    G[to].push_back(Edge(from, 0, -cost, G[from].size() - 1));
  }

  int Solve(int s, int t, int f) {
#ifdef BELLMANFORD
    int res = 0;
    while (f > 0) {
      fill(dist, dist + V, INF);
      dist[s] = 0;
      bool update = true;
      while (update) {
        update = false;
        for (int v = 0; v < V; v++) {
          if (dist[v] == INF) {
            continue;
          }
          for (int i = 0; i < G[v].size(); i++) {
            Edge &e = G[v][i];
            if (e.cap > 0 && dist[e.to] > dist[v] + e.cost) {
              dist[e.to] = dist[v] + e.cost;
              prevv[e.to] = v;
              preve[e.to] = i;
              update = true;
            }
          }
        }
      }
      if (dist[t] == INF) {
        return -1;
      }
      int d = f;
      for (int v = t; v != s; v = prevv[v]) {
        d = min(d, G[prevv[v]][preve[v]].cap);
      }
      f -= d;
      res += d * dist[t];
      for (int v = t; v != s; v = prevv[v]) {
        Edge &e = G[prevv[v]][preve[v]];
        e.cap -= d;
        G[v][e.rev].cap += d;
      }
    }

    return res;
#elif defined DIJKSTRA
    int res = 0;
    fill(h, h + V, 0);
    
    while (f > 0) {
      priority_queue<P, vector<P>, greater<P>> que;
      fill(dist, dist + V, INF);
      dist[s] = 0;
      que.push(P(0, s));
      while (!que.empty()) {
        P p = que.top(); que.pop();
        int v = p.second;
        if (dist[v] < p.first) {
          continue;
        }
        for (int i = 0; i < G[v].size(); i++) {
          Edge &e = G[v][i];
          if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
            dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
            prevv[e.to] = v;
            preve[e.to] = i;
            que.push(P(dist[e.to], e.to));
          }
        }
      }
      if (dist[t] == INF) {
        return -1;
      }
      for (int v = 0; v < V; v++) {
        h[v] += dist[v];
      }
      int d = f;
      for (int v = t; v != s; v = prevv[v]) {
        d = min(d, G[prevv[v]][preve[v]].cap);
      }
      f -= d;
      res += d * h[t];
      for (int v = t; v != s; v = prevv[v]) {
        Edge &e = G[prevv[v]][preve[v]];
        e.cap -= d;
        G[v][e.rev].cap += d;
      }
    }

    return res;    
#else
    assert(false);
#endif
  }
};

int main() {
  int V, E, F;
  cin >> V >> E >> F;

  MinCostFlow mcf(V);

  for (int i = 0; i < E; i++) {
    int u, v, c, d;
    cin >> u >> v >> c >> d;
    mcf.AddEdge(u, v, c, d);
  }
  
  int s = 0, t = V - 1;
  int ans = mcf.Solve(s, t, F);

  cout << ans << endl;
  
  return 0;
}

Measured memory_bytes: 3412