2 2
1 2 1 4 2 4
1 2 3 4 4 4
 2 2
1 2 0 9998 0 9999
2 1 0 9999 0 10000
 3 3
1 2 0 3 -4 7
2 3 -2 5 1 6
3 1 0 4 0 4
 2 2
1 2 0 3 0 3
2 1 0 4 0 4
 2 2
1 2 0 0 0 0
2 1 0 0 0 0
 5 10
4 3 -19 49 -11 65
4 4 50 12 -2 65
1 5 56 8 -5 76
5 1 -28 33 -38 49
4 2 0 0 2 9
4 2 0 0 14 8
3 1 26 67 15 85
5 3 -51 98 -44 99
1 3 -33 65 -20 65
3 4 30 6 -30 70
 5 10
4 3 -8 16 -29 72
4 4 -62 65 33 65
1 5 -58 97 -17 97
5 1 -5 10 -68 88
4 2 0 0 -9 60
4 2 0 0 -23 39
3 1 3 28 13 87
5 3 -1 25 -15 90
1 3 -12 33 6 94
3 4 -71 86 -39 86
 5 10
4 3 -1 5 -6 98
4 4 12 14 -43 98
1 5 -4 6 8 88
5 1 0 0 -9 100
4 2 0 0 6 50
4 2 0 0 -39 77
3 1 1 4 -1 100
5 3 -7 13 9 88
1 3 2 0 -7 100
3 4 2 0 3 88
 2 2
1 1 0 4 0 5
2 2 4 0 5 0
 2 2
1 2 0 4 0 4
2 1 0 4 0 4
 2 2
1 2 0 3 0 5
2 1 0 4 0 6

0
 1.0000000000
 0.2500000000
 0
 1.0000000000
 0.2121212000
 0.6666666000
 1.0000000000
 1.0000000000
 1.0000000000
 1.0000000000

#include <bits/stdc++.h>
using namespace std;
namespace Dinic {
const long long INF = 1LL << 60;
const int N = 1100;
const int M = 11000;
int fst[N], nxt[M], to[M];
long long cap[M];
int dis[N], q[N], ptr[N];
int V, E;
void init() {
  memset(fst, -1, sizeof fst);
  V = E = 0;
}
inline int add_node() {
  V++;
  return V - 1;
}
inline void add_edge(int u, int v, long long c) {
  to[E] = v, cap[E] = c, nxt[E] = fst[u], fst[u] = E++;
  to[E] = u, cap[E] = 0, nxt[E] = fst[v], fst[v] = E++;
}
inline bool bfs(int S, int T, int n) {
  memset(dis, -1, sizeof(int) * n);
  int h = 0, t = 0;
  dis[S] = 0, q[t++] = S;
  while (h < t) {
    int u = q[h++];
    for (int e = fst[u]; ~e; e = nxt[e])
      if (cap[e] > 0 && dis[to[e]] == -1) {
        dis[to[e]] = dis[u] + 1, q[t++] = to[e];
        if (to[e] == T) return 1;
      }
  }
  return (dis[T] != -1);
}
long long dfs(int u, int T, long long f) {
  if (u == T) return f;
  for (int &e = ptr[u]; ~e; e = nxt[e])
    if (cap[e] > 0 && dis[to[e]] > dis[u]) {
      long long ret = dfs(to[e], T, min(f, cap[e]));
      if (ret > 0) {
        cap[e] -= ret, cap[e ^ 1] += ret;
        return ret;
      }
    }
  return 0;
}
long long max_flow(int S, int T, int n = V) {
  long long ret = 0;
  while (bfs(S, T, n)) {
    memcpy(ptr, fst, sizeof(int) * n);
    for (long long cur; (cur = dfs(S, T, INF)) > 0; ret += cur)
      ;
  }
  return ret;
}
}  // namespace Dinic
long long ssum[1100], tsum[1100];
int n, m;
const int D = 10000000;
struct Edge {
  int u, v, a, b, c, d;
  void input() { scanf("%d%d%d%d%d%d", &u, &v, &a, &b, &c, &d); }
} e[2200];
long long calc(int mid) {
  Dinic::init();
  for (int i = 1; i <= n; i++) ssum[i] = tsum[i] = 0;
  for (int i = 1; i <= m; i++) {
    int u = e[i].u, v = e[i].v;
    long long l = e[i].a * 1LL * mid + e[i].b * 1LL * D;
    long long r = e[i].c * 1LL * mid + e[i].d * 1LL * D;
    ssum[v] += l, tsum[u] += l;
    Dinic::add_edge(u, v, r - l);
  }
  for (int i = 1; i <= n; i++) {
    if (ssum[i]) Dinic::add_edge(0, i, ssum[i]);
    if (tsum[i]) Dinic::add_edge(i, n + 1, tsum[i]);
  }
  long long tot = 0;
  for (int i = 1; i <= n; i++) tot += ssum[i];
  return tot - Dinic::max_flow(0, n + 1, n + 2);
}
int main() {
  scanf("%d%d", &n, &m);
  for (int i = 1; i <= m; i++) e[i].input();
  int st = 0, en = D;
  while (st < en - 1) {
    int mid1 = (st * 2 + en) / 3;
    int mid2 = (st + en * 2) / 3;
    long long ret1 = calc(mid1);
    if (ret1 == 0) {
      st = en = mid1;
      break;
    }
    long long ret2 = calc(mid2);
    if (ret2 == 0) {
      st = en = mid2;
      break;
    }
    if (ret1 > ret2) {
      st = mid1 + 1;
    } else {
      en = mid2;
    }
  }
  int ans = 0;
  {
    int lo = 0, hi = st;
    while (lo < hi) {
      int mid = lo + hi >> 1;
      if (calc(mid) == 0)
        hi = mid;
      else
        lo = mid + 1;
    }
    ans -= lo;
  }
  {
    int lo = st, hi = D;
    while (lo < hi) {
      int mid = lo + hi + 1 >> 1;
      if (calc(mid) == 0)
        lo = mid;
      else
        hi = mid - 1;
    }
    ans += lo;
  }
  printf("%.10lf\n", ans * 1.0 / D);
  return 0;
}
