For problem statement at 1000-1999/1400-1499/1480-1489/1482/problemF.txt this is a correct solution, but verifier at 1000-1999/1400-1499/1480-1489/1482/verifierF.go ends with All tests passed can you fix the verifier? package main

import (
	"fmt"
	"io"
	"os"
)

type FastScanner struct {
	data []byte
	idx  int
}

func (fs *FastScanner) NextInt() int {
	n := len(fs.data)
	for fs.idx < n && (fs.data[fs.idx] < '0' || fs.data[fs.idx] > '9') {
		fs.idx++
	}
	val := 0
	for fs.idx < n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		val = val*10 + int(c-'0')
		fs.idx++
	}
	return val
}

type Edge struct {
	u, v int
	w    int64
}

type Query struct {
	to int
	l  int64
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := FastScanner{data: data}

	n := fs.NextInt()
	m := fs.NextInt()

	const INF int64 = 1 << 60
	const NEG int64 = -1 << 60

	dist := make([]int64, n*n)
	for i := range dist {
		dist[i] = INF
	}
	for i := 0; i < n; i++ {
		dist[i*n+i] = 0
	}

	edges := make([]Edge, m)
	for i := 0; i < m; i++ {
		u := fs.NextInt() - 1
		v := fs.NextInt() - 1
		w := int64(fs.NextInt())
		edges[i] = Edge{u: u, v: v, w: w}
		dist[u*n+v] = w
		dist[v*n+u] = w
	}

	for k := 0; k < n; k++ {
		dk := dist[k*n : (k+1)*n]
		for i := 0; i < n; i++ {
			di := dist[i*n : (i+1)*n]
			ik := di[k]
			if ik == INF {
				continue
			}
			for j := 0; j < n; j++ {
				nd := ik + dk[j]
				if nd < di[j] {
					di[j] = nd
				}
			}
		}
	}

	q := fs.NextInt()
	qs := make([][]Query, n)
	for i := 0; i < q; i++ {
		u := fs.NextInt() - 1
		v := fs.NextInt() - 1
		l := int64(fs.NextInt())
		qs[u] = append(qs[u], Query{to: v, l: l})
		qs[v] = append(qs[v], Query{to: u, l: l})
	}

	useful := make([]bool, m)
	best := make([]int64, n)
	remaining := m

	for s := 0; s < n && remaining > 0; s++ {
		if len(qs[s]) == 0 {
			continue
		}
		for i := 0; i < n; i++ {
			best[i] = NEG
		}
		for _, qu := range qs[s] {
			dt := dist[qu.to*n : (qu.to+1)*n]
			lim := qu.l
			for x := 0; x < n; x++ {
				val := lim - dt[x]
				if val > best[x] {
					best[x] = val
				}
			}
		}
		ds := dist[s*n : (s+1)*n]
		for i, e := range edges {
			if useful[i] {
				continue
			}
			if ds[e.u]+e.w <= best[e.v] || ds[e.v]+e.w <= best[e.u] {
				useful[i] = true
				remaining--
			}
		}
	}

	fmt.Println(m - remaining)
}