#include <bits/stdc++.h>
using namespace std;
using Edge = tuple<int64_t, int64_t, int64_t>;
int64_t inv(int64_t e) { return e ^ 1; }
constexpr int64_t INF = 100000000000;
int64_t ek(int64_t V, int64_t s, int64_t t, vector<Edge> &edges) {
  int64_t E = 2 * edges.size();
  vector<int64_t> start(V);
  fill(start.begin(), start.end(), -1);
  vector<int64_t> succ(E), cap(E), to(E);
  int64_t edge_counter = 0;
  auto add_edge = [&](int64_t u, int64_t v, int64_t c) {
    cap[edge_counter] = c, to[edge_counter] = v;
    succ[edge_counter] = start[u];
    start[u] = edge_counter++;
  };
  for (auto e : edges) {
    int64_t u, v, C;
    tie(u, v, C) = e;
    add_edge(u, v, C);
    add_edge(v, u, 0);
  }
  vector<int64_t> seen(V);
  vector<int64_t> path(V);
  auto augment = [&](int64_t u, int64_t t, int64_t f) {
    queue<int64_t> q;
    fill(path.begin(), path.end(), -1);
    for (q.push(s), path[s] = -2; !q.empty(); q.pop()) {
      int64_t u = q.front();
      for (int64_t e = start[u]; ~e; e = succ[e]) {
        if (cap[e] <= 0) continue;
        int64_t v = to[e];
        if (path[v] == -1) {
          path[v] = e;
          q.push(v);
        }
      }
    }
    if (path[t] == -1) return (int64_t)0;
    int64_t r = INF;
    for (int64_t e = path[t]; e != -2; e = path[to[inv(e)]]) r = min(r, cap[e]);
    for (int64_t e = path[t]; e != -2; e = path[to[inv(e)]]) {
      cap[e] -= r;
      cap[inv(e)] += r;
    }
    return r;
  };
  int64_t res = 0;
  int64_t r;
  while (r = augment(s, t, 1)) {
    fill(seen.begin(), seen.begin() + V, 0);
    res += r;
  }
  return res;
}
int main() {
  int64_t n, m, x;
  cin >> n >> m >> x;
  int64_t s = 0, t = n;
  int64_t V = n + 1;
  vector<Edge> edges;
  vector<int64_t> C;
  edges.push_back({s, 1, x});
  for (int64_t i = 0; i < m; i++) {
    int64_t a, b, c;
    cin >> a >> b >> c;
    edges.push_back({a, b, c});
    C.push_back(c);
  }
  auto test = [&](double tw) {
    double bw = tw / x;
    for (int64_t i = 1; i < edges.size(); i++) {
      get<2>(edges[i]) = floor(C[i - 1] / bw);
    }
    return x <= ek(V, s, t, edges);
  };
  double lo = 0;
  double hi = 416008400;
  double bestsofar = -1;
  while (lo <= hi) {
    double mid = (lo + hi) / 2;
    if (!test(mid)) {
      bestsofar = mid;
      hi = mid - 0.000001;
    } else {
      lo = mid + 0.000001;
    }
  }
  printf("%0.10f\n", bestsofar);
}
