#include <bits/stdc++.h>
using namespace std;
const int iinf = 0x7fffffff;
const long long linf = ~(1LL << 63);
template <typename T>
inline T gcd(T a, T b) {
  if (a < 0) return gcd(-a, b);
  if (b < 0) return gcd(a, -b);
  if (a < b) return gcd(b, a);
  if (b == 0) return a;
  return gcd(b, a % b);
}
long long qpow(long long a, long long n, long long mod) {
  a %= mod;
  long long ans = 1LL;
  while (n) {
    if (n & 1) ans = (ans * a % mod);
    a = (a * a % mod);
    n >>= 1;
  }
  return ans;
}
inline long long rev(long long a, long long p) { return qpow(a, p - 2, p); }
inline int in() {
  int x;
  cin >> x;
  return x;
}
inline void tic() {}
inline void toc() {}
const int maxn = 100;
struct edge {
  int from, to, cap;
} E[555];
struct MaximumFlow {
  static const long long INF = 0x3f3f3f3f3f3f3f3fll;
  static const long long InfCapacity = INF;
  struct Edge {
    int to;
    long long capacity;
    int rev;
  };
  vector<vector<Edge> > g;
  void init(int n) { g.assign(n, vector<Edge>()); }
  void add(int i, int j, long long capacity) {
    Edge e, f;
    e.to = j, f.to = i;
    e.capacity = capacity, f.capacity = 0;
    g[i].push_back(e);
    g[j].push_back(f);
    g[i].back().rev = (int)g[j].size() - 1;
    g[j].back().rev = (int)g[i].size() - 1;
  }
  void addB(int i, int j, long long capacity) {
    Edge e, f;
    e.to = j, f.to = i;
    e.capacity = capacity, f.capacity = capacity;
    g[i].push_back(e);
    g[j].push_back(f);
    g[i].back().rev = (int)g[j].size() - 1;
    g[j].back().rev = (int)g[i].size() - 1;
  }
  long long maximumFlow(int s, int t) {
    int n = g.size();
    vector<int> level(n);
    long long total = 0;
    bool update;
    do {
      update = false;
      fill(level.begin(), level.end(), -1);
      level[s] = 0;
      queue<int> q;
      q.push(s);
      for (int d = n; !q.empty() && level[q.front()] < d;) {
        int u = q.front();
        q.pop();
        if (u == t) d = level[u];
        for (auto e = (g[u]).begin(); e != (g[u]).end(); ++e)
          if (e->capacity > 0 && level[e->to] == -1)
            q.push(e->to), level[e->to] = level[u] + 1;
      }
      vector<int> iter(n);
      for (int i = 0; i < n; i++) iter[i] = (int)g[i].size() - 1;
      while (1) {
        long long f = augment(level, iter, s, t, InfCapacity);
        if (f == 0) break;
        total += f;
        update = true;
      }
    } while (update);
    return total;
  }
  long long augment(vector<int> &level, vector<int> &iter, int u, int t,
                    long long f) {
    if (u == t || f == 0) return f;
    int lv = level[u];
    if (lv == -1) return 0;
    level[u] = -1;
    for (; iter[u] >= 0; --iter[u]) {
      Edge &e = g[u][iter[u]];
      if (level[e.to] <= lv) continue;
      long long l = augment(level, iter, e.to, t, min(f, e.capacity));
      if (l == 0) continue;
      e.capacity -= l;
      g[e.to][e.rev].capacity += l;
      level[u] = lv;
      return l;
    }
    return 0;
  }
};
int n, m, x;
MaximumFlow mf;
double get(double every_bear) {
  int S = 0, T = n + 1;
  mf.init(T + 1);
  mf.add(S, 1, MaximumFlow::INF);
  mf.add(n, T, MaximumFlow::INF);
  for (int i = 0; i < m; i++) {
    double bears = floor(E[i].cap / every_bear);
    bears = min(bears, (double)x);
    int c = (int)bears;
    mf.add(E[i].from, E[i].to, c);
  }
  long long flow = mf.maximumFlow(S, T);
  if (flow < x) return 0;
  return min(flow, (long long)x) * every_bear;
}
int main() {
  ios::sync_with_stdio(0);
  cin >> n >> m >> x;
  for (int i = 0; i < m; i++) cin >> E[i].from >> E[i].to >> E[i].cap;
  double l = 0, r = 1000000000000.0;
  while (r - l > 1e-7) {
    double m1 = (l + r) / 2;
    double r1 = get(m1 / x);
    if (abs(r1 - m1) > 1e-5) {
      r = m1;
    } else {
      l = m1;
    }
  }
  cout << fixed << setprecision(8) << (l + r) / 2 << endl;
  return 0;
}
