Problem: Berland traffic is very different from traffic in other countries. The capital of Berland consists of n junctions and m roads. Each road connects a pair of junctions. There can be multiple roads between a pair of junctions. For each road we know its capacity: value ci is the maximum number of cars that can drive along a road in any direction per a unit of time. For each road, the cars can drive along it in one of two direction. That it, the cars can't simultaneously move in both directions. A road's traffic is the number of cars that goes along it per a unit of time. For road (ai, bi) this value is negative, if the traffic moves from bi to ai. A road's traffic can be a non-integer number.

The capital has two special junctions — the entrance to the city (junction 1) and the exit from the city (junction n). For all other junctions it is true that the traffic is not lost there. That is, for all junctions except for 1 and n the incoming traffic sum equals the outgoing traffic sum.

Traffic has an unusual peculiarity in the capital of Berland — for any pair of junctions (x, y) the sum of traffics along any path from x to y doesn't change depending on the choice of the path. Such sum includes traffic along all roads on the path (possible with the "minus" sign, if the traffic along the road is directed against the direction of the road on the path from x to y).

Your task is to find the largest traffic that can pass trough the city per one unit of time as well as the corresponding traffic for each road. 

Input

The first line contains a positive integer n — the number of junctions (2 ≤ n ≤ 100). The second line contains integer m (1 ≤ m ≤ 5000) — the number of roads. Next m lines contain the roads' descriptions. Each road contains a group of three numbers ai, bi, ci, where ai, bi are the numbers of junctions, connected by the given road, and ci (1 ≤ ai, bi ≤ n; ai ≠ bi; 0 ≤ ci ≤ 10000) is the largest permissible traffic along this road.

Output

In the first line print the required largest traffic across the city. Then print m lines, on each line print the speed, at which the traffic moves along the corresponding road. If the direction doesn't match the order of the junctions, given in the input, then print the traffic with the minus sign. Print the numbers with accuracy of at least five digits after the decimal point.

If there are many optimal solutions, print any of them.

Examples

Input

2
3
1 2 2
1 2 4
2 1 1000


Output

6.00000
2.00000
2.00000
-2.00000


Input

7
11
1 2 7
1 2 7
1 3 7
1 4 7
2 3 7
2 5 7
3 6 7
4 7 7
5 4 7
5 6 7
6 7 7


Output

13.00000
2.00000
2.00000
3.00000
6.00000
1.00000
3.00000
4.00000
7.00000
1.00000
2.00000
6.00000

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
int n, m, a[5010], b[5010], d[110][110];
double mat[110][110], res[110], flow[110][110], c[5010], ans;
bool used[110];
void input() {
  memset(flow, 0x7f, sizeof(flow));
  cin >> n >> m;
  for (int i = 0; i < m; ++i) {
    cin >> a[i] >> b[i] >> c[i];
    ++d[a[i]][b[i]], ++d[b[i]][a[i]];
    flow[a[i]][b[i]] = flow[b[i]][a[i]] = min(flow[a[i]][b[i]], c[i]);
  }
}
bool achievable(int x) {
  bool flg = (x == n);
  used[x] = 1;
  for (int i = 1; i <= n; ++i)
    if (!used[i] && d[x][i]) flg |= achievable(i);
  return flg;
}
void check() {
  if (!achievable(1)) {
    for (int i = 0; i <= m; puts("0.00000"), ++i)
      ;
    exit(0);
  }
}
void potential() {
  res[1] = 1.0, mat[n][n] = 1.0;
  for (int i = 1; i < n; ++i) {
    if (!used[i]) {
      mat[i][i] = 1.0;
      continue;
    }
    for (int j = 1; j <= n; ++j)
      if (j != i) mat[i][i] += 1.0 * d[i][j], mat[i][j] -= 1.0 * d[i][j];
  }
}
void Gauss() {
  for (int i = 1; i <= n; ++i) {
    int ind = i;
    for (int j = i + 1; j <= n; ++j)
      if (((mat[j][i]) > 0 ? (mat[j][i]) : (-mat[j][i])) >
          ((mat[ind][i]) > 0 ? (mat[ind][i]) : (-mat[ind][i])))
        ind = j;
    if (ind != i)
      for (int j = i; j <= n; ++j) swap(mat[ind][j], mat[i][j]);
    swap(res[ind], res[i]);
    for (int j = 1; j <= n; ++j) {
      if (i == j) continue;
      double ratio = -mat[j][i] / mat[i][i];
      for (int k = i; k <= n; ++k) mat[j][k] += ratio * mat[i][k];
      res[j] += ratio * res[i];
    }
  }
  for (int i = 1; i <= n; ++i)
    if (((mat[i][i]) > 0 ? (mat[i][i]) : (-mat[i][i])) > 1e-8)
      res[i] /= mat[i][i];
}
void output() {
  ans = 1.0e9;
  for (int i = 0; i < m; ++i)
    if ((((res[a[i]] - res[b[i]])) > 0 ? ((res[a[i]] - res[b[i]]))
                                       : (-(res[a[i]] - res[b[i]]))) > 1e-8)
      ans = min(ans, flow[a[i]][b[i]] / (((res[a[i]] - res[b[i]])) > 0
                                             ? ((res[a[i]] - res[b[i]]))
                                             : (-(res[a[i]] - res[b[i]]))));
  cout << fixed << setprecision(9) << ans << endl;
  for (int i = 0; i < m; ++i)
    cout << fixed << setprecision(9) << (res[a[i]] - res[b[i]]) * ans << endl;
}
int main() {
  input();
  check();
  potential();
  Gauss();
  output();
  return 0;
}