For problem statement at 0-999/500-599/500-509/507/problemE.txt this is a correct solution, but verifier at 0-999/500-599/500-509/507/verifierE.go ends with test 1 failed
expected:
10
3 5 0
1 7 1
2 6 0
4 6 0
1 5 0
2 7 0
3 7 0
3 4 0
2 5 0
6 7 0
got:
10
1 7 1
3 5 0
2 6 0
4 6 0
1 5 0
2 7 0
3 7 0
3 4 0
2 5 0
6 7 0

exit status 1 can you fix the verifier? ```go
package main

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

type Pair struct {
	to int
	z  int
}

type Edge struct {
	x, y, z int
}

type Pii struct {
	a, b int
}

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, m int
	fmt.Fscan(in, &n, &m)

	adj := make([][]Pair, n+1)
	all_edges := make([]Edge, 0, m)
	for i := 0; i < m; i++ {
		var x, y, z int
		fmt.Fscan(in, &x, &y, &z)
		adj[x] = append(adj[x], Pair{y, z})
		adj[y] = append(adj[y], Pair{x, z})
		all_edges = append(all_edges, Edge{x, y, z})
	}

	const INF = 1000000000
	d := make([]int, n+1)
	for i := range d {
		d[i] = INF
	}
	d[1] = 0

	queue := make([]int, 0)
	queue = append(queue, 1)
	qp := 0
	for qp < len(queue) {
		u := queue[qp]
		qp++
		for _, p := range adj[u] {
			v := p.to
			if d[v] > d[u]+1 {
				d[v] = d[u] + 1
				queue = append(queue, v)
			}
		}
	}

	levels := make([][]int, n)
	maxd := 0
	for i := 1; i <= n; i++ {
		if d[i] < INF {
			levels[d[i]] = append(levels[d[i]], i)
			if d[i] > maxd {
				maxd = d[i]
			}
		}
	}

	maxones := make([]int, n+1)
	for i := range maxones {
		maxones[i] = math.MinInt32 / 2
	}
	maxones[1] = 0

	pred := make([]int, n+1)
	for i := range pred {
		pred[i] = -1
	}
	edge_z_to := make([]int, n+1)
	for i := range edge_z_to {
		edge_z_to[i] = -1
	}

	for k := 0; k < maxd; k++ {
		for _, u := range levels[k] {
			for _, p := range adj[u] {
				v := p.to
				zz := p.z
				if d[v] == d[u]+1 {
					newo := maxones[u] + zz
					if newo > maxones[v] {
						maxones[v] = newo
						pred[v] = u
						edge_z_to[v] = zz
					}
				}
			}
		}
	}

	type Action struct {
		x, y, op int
	}
	actions := make([]Action, 0)

	path_edge_set := make(map[Pii]bool)

	cur := n
	for cur != 1 {
		prev := pred[cur]
		this_z := edge_z_to[cur]

		aa, bb := prev, cur
		if aa > bb {
			aa, bb = bb, aa
		}
		path_edge_set[Pii{aa, bb}] = true

		if this_z == 0 {
			actions = append(actions, Action{prev, cur, 1})
		}
		cur = prev
	}

	for _, e := range all_edges {
		aa, bb := e.x, e.y
		if aa > bb {
			aa, bb = bb, aa
		}
		if path_edge_set[Pii{aa, bb}] {
			continue
		}
		if e.z == 1 {
			actions = append(actions, Action{e.x, e.y, 0})
		}
	}

	k := len(actions)
	fmt.Println(k)
	for _, act := range actions {
		fmt.Printf("%d %d %d\n", act.x, act.y, act.op)
	}
}
```