```go
package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
)

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, m int
	if _, err := fmt.Fscan(in, &n, &m); err != nil {
		return
	}

	type Edge struct {
		u, v int
		c    float64
	}

	edges := make([]Edge, m)
	mat := make([][]float64, n)
	for i := range mat {
		mat[i] = make([]float64, n+1)
	}

	for i := 0; i < m; i++ {
		var u, v int
		var c float64
		fmt.Fscan(in, &u, &v, &c)
		u--
		v--
		edges[i] = Edge{u, v, c}
		if u != 0 && u != n-1 {
			mat[u][u] += 1
			mat[u][v] -= 1
		}
		if v != 0 && v != n-1 {
			mat[v][v] += 1
			mat[v][u] -= 1
		}
	}

	mat[0][0] = 1
	mat[0][n] = 1

	mat[n-1][n-1] = 1
	mat[n-1][n] = 0

	r := 0
	for c := 0; c < n; c++ {
		pivot := r
		for i := r; i < n; i++ {
			if math.Abs(mat[i][c]) > math.Abs(mat[pivot][c]) {
				pivot = i
			}
		}
		if pivot < n && math.Abs(mat[pivot][c]) > 1e-9 {
			mat[r], mat[pivot] = mat[pivot], mat[r]
			val := mat[r][c]
			for j := c; j <= n; j++ {
				mat[r][j] /= val
			}
			for i := 0; i < n; i++ {
				if i != r {
					val := mat[i][c]
					for j := c; j <= n; j++ {
						mat[i][j] -= val * mat[r][j]
					}
				}
			}
			r++
		}
	}

	p := make([]float64, n)
	for i := 0; i < r; i++ {
		for c := 0; c < n; c++ {
			if math.Abs(mat[i][c]-1) < 1e-9 {
				p[c] = mat[i][n]
				break
			}
		}
	}

	S := math.Inf(1)
	for i := 0; i < m; i++ {
		f := p[edges[i].u] - p[edges[i].v]
		if math.Abs(f) > 1e-9 {
			val := edges[i].c / math.Abs(f)
			if val < S {
				S = val
			}
		}
	}

	if math.IsInf(S, 1) {
		S = 0
	}

	total := 0.0
	for i := 0; i < m; i++ {
		if edges[i].u == 0 {
			total += S * (p[edges[i].u] - p[edges[i].v])
		} else if edges[i].v == 0 {
			total -= S * (p[edges[i].u] - p[edges[i].v])
		}
	}

	fmt.Printf("%.10f\n", total)
	for i := 0; i < m; i++ {
		fmt.Printf("%.10f\n", S*(p[edges[i].u]-p[edges[i].v]))
	}
}
```