#include <bits/stdc++.h>
using namespace std;
using ld = long double;
template <typename Weight>
class max_flow {
  struct edge {
    int to, rev;
    Weight cap;
    edge(int t, Weight c, int r) : to(t), rev(r), cap(c) {}
  };
  vector<vector<edge>> G;
  vector<int> level;
  vector<size_t> iter;
  const Weight inf;
  void bfs(int s) {
    fill(level.begin(), level.end(), -1);
    queue<int> que;
    level[s] = 0;
    que.push(s);
    while (!que.empty()) {
      int v = que.front();
      que.pop();
      for (size_t i = 0; i < G[v].size(); i++) {
        edge &e = G[v][i];
        if (e.cap > 0 && level[e.to] < 0) {
          level[e.to] = level[v] + 1;
          que.push(e.to);
        }
      }
    }
  }
  Weight dfs(int v, int t, Weight f) {
    if (v == t) return f;
    for (size_t &i = iter[v]; i < G[v].size(); i++) {
      edge &e = G[v][i];
      edge &re = G[e.to][e.rev];
      if (re.cap > 0 && level[v] > level[e.to]) {
        Weight d = dfs(e.to, t, min(f, re.cap));
        if (d > 0) {
          re.cap -= d;
          e.cap += d;
          return d;
        }
      }
    }
    return 0;
  }

 public:
  max_flow(int n, Weight inf_) : G(n), level(n), iter(n), inf(inf_) {}
  void add(int a, int b, Weight cap) {
    G[a].emplace_back(b, cap, G[b].size());
    G[b].emplace_back(a, (Weight)0, G[a].size() - 1);
  }
  Weight dinic(int s, int t) {
    Weight flow = 0;
    while (bfs(s), level[t] >= 0) {
      fill(iter.begin(), iter.end(), 0);
      while (true) {
        Weight f = dfs(t, s, inf);
        if (f <= 0) break;
        flow += f;
      }
    }
    return flow;
  }
};
const int INF = 2e5;
int main() {
  int N, M, X;
  cin >> N >> M >> X;
  vector<int> a(M), b(M), c(M);
  for (int i = 0; i < M; i++) {
    cin >> a[i] >> b[i] >> c[i];
    --a[i], --b[i];
  }
  ld lb = 0, ub = 1e18;
  int cnt = 300;
  while (cnt--) {
    ld v = (lb + ub) / 2;
    ld m = v / X;
    max_flow<int> mf(N, INF);
    int s = 0, t = N - 1;
    for (int i = 0; i < M; i++) {
      int cost = m < (ld)c[i] / INF ? INF : max(0, min(INF, (int)(c[i] / m)));
      if (cost > 0) mf.add(a[i], b[i], cost);
    }
    if (mf.dinic(s, t) < X) {
      ub = v;
    } else {
      lb = v;
    }
  }
  cout << fixed << setprecision(12) << lb << endl;
  return 0;
}
