#include <bits/stdc++.h>
using namespace std;
int ans;
int m, n, maxflow;
const int length = 1000;
const int mymax = -1;
int path[2000];
int id[2000];
int thetop = 0;
int a[505][3];
class mincostMaxFlow {
 private:
  int flow[length * 2];
  int capacity[length * 2];
  int value[length * 2];
  int head[length];
  int next[length];
  bool isvisited[length * 2];
  int queue[length * 5];
  int dist[length];
  int cost[length];
  int pos;
  int e[length];
  int prev[length];
  int source;
  int target;
  int prev_vec[length];
  double smallest;

 public:
  void init(int s, int e) {
    source = s;
    target = e;
    pos = 0;
    clear();
  }
  void clear() {
    memset(head, -1, sizeof(head));
    memset(flow, 0, sizeof(flow));
    memset(capacity, 0, sizeof(capacity));
    pos = 0;
  }
  void reset(double d) {
    for (int i = 0; i < pos; i++) {
      flow[i] = 0.0;
    }
    smallest = d;
  }
  void add(int s, int t, int cap, int v) {
    e[pos] = t;
    cost[pos] = v;
    capacity[pos] = (double)cap;
    next[pos] = head[s];
    head[s] = pos++;
    e[pos] = s;
    cost[pos] = -v;
    next[pos] = head[t];
    head[t] = pos++;
  }
  bool find() {
    memset(isvisited, false, sizeof(isvisited));
    int start = 0;
    int end = 1;
    queue[start] = source;
    int l = 0;
    while (start < end) {
      int t = queue[start++];
      for (int i = head[t]; i != -1; i = next[i]) {
        if (capacity[i] - flow[i] > 0 && !isvisited[e[i]]) {
          prev[e[i]] = i;
          queue[end++] = e[i];
          isvisited[e[i]] = true;
          if (e[i] == target) return true;
        }
      }
    }
    return false;
  }
  int getmaxflow_mincost() {
    int i = 0;
    int j = 1;
    ans = 0;
    i = 0;
    ;
    int l = 0;
    while (find()) {
      int max = INT_MAX;
      int t = target;
      while (t != source) {
        int i = prev[t];
        if (max > capacity[i] - flow[i]) {
          max = capacity[i] - flow[i];
        }
        t = e[i ^ 1];
      }
      ans += max;
      t = target;
      while (t != source) {
        int i = prev[t];
        flow[i] += max;
        flow[i ^ 1] = -flow[i];
        prev_vec[t] = e[i ^ 1];
        t = e[i ^ 1];
      }
      j++;
    }
    return ans;
  }
  void getcost() {
    int s, t;
    for (int i = 0; i < pos; i++) {
      if (flow[i] > 0) {
        t = e[i] / 2;
        s = e[i ^ 1] / 2;
        path[t] = s;
      }
    }
    int cnt = 1;
    for (int i = 0; i < n; i++) {
      if (path[i] >= n) {
        id[i] = cnt++;
      } else {
        id[i] = id[path[i]];
      }
    }
  }
};
mincostMaxFlow solution;
void process() {
  int i, j, t;
  int ret = 0;
}
void input() {
  int i, j, t, k, u, v;
  int s;
  scanf("%d %d %d", &n, &m, &thetop);
  t = 0;
  solution.init(1, n);
  for (i = 0; i < m; i++) {
    scanf("%d %d %d", &a[i][0], &a[i][1], &a[i][2]);
    if (a[i][2] > t) t = a[i][2];
  }
  double l = 0;
  double h = (double)t;
  double mid;
  double diff = 0.00000000001;
  int c = 0;
  while (l + diff < h) {
    mid = (l + h) / 2;
    solution.clear();
    for (i = 0; i < m; i++) {
      k = (int)((double)a[i][2] / mid);
      if (k > 0)
        solution.add(a[i][0], a[i][1], k, 0);
      else if (k == -2147483648)
        solution.add(a[i][0], a[i][1], INT_MAX, 0);
    }
    v = solution.getmaxflow_mincost();
    if (v >= thetop) {
      l = mid;
    } else {
      h = mid;
    }
    c++;
    if (c >= 100) break;
  }
  printf("%lf\n", l * thetop);
}
int main() {
  input();
  process();
  return 0;
}
