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

import (
	"io"
	"os"
	"strconv"
)

type MinHeap struct {
	a    []int32
	pos  []int32
	dist []int64
}

func (h *MinHeap) Len() int {
	return len(h.a) - 1
}

func (h *MinHeap) up(i int32) {
	for i > 1 {
		p := i >> 1
		if h.dist[h.a[p]] <= h.dist[h.a[i]] {
			break
		}
		h.a[p], h.a[i] = h.a[i], h.a[p]
		h.pos[h.a[p]] = p
		h.pos[h.a[i]] = i
		i = p
	}
}

func (h *MinHeap) down(i int32) {
	n := int32(len(h.a) - 1)
	for {
		l := i << 1
		if l > n {
			break
		}
		j := l
		r := l + 1
		if r <= n && h.dist[h.a[r]] < h.dist[h.a[l]] {
			j = r
		}
		if h.dist[h.a[i]] <= h.dist[h.a[j]] {
			break
		}
		h.a[i], h.a[j] = h.a[j], h.a[i]
		h.pos[h.a[i]] = i
		h.pos[h.a[j]] = j
		i = j
	}
}

func (h *MinHeap) Push(s int32) {
	h.a = append(h.a, s)
	i := int32(len(h.a) - 1)
	h.pos[s] = i
	h.up(i)
}

func (h *MinHeap) Decrease(s int32) {
	h.up(h.pos[s])
}

func (h *MinHeap) Pop() int32 {
	root := h.a[1]
	last := h.a[len(h.a)-1]
	h.a = h.a[:len(h.a)-1]
	if len(h.a) == 1 {
		h.pos[root] = -1
		return root
	}
	h.a[1] = last
	h.pos[last] = 1
	h.pos[root] = -1
	h.down(1)
	return root
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	p := 0
	nextInt := func() int {
		for p < len(data) && (data[p] < '0' || data[p] > '9') {
			p++
		}
		v := 0
		for p < len(data) && data[p] >= '0' && data[p] <= '9' {
			v = v*10 + int(data[p]-'0')
			p++
		}
		return v
	}

	n := nextInt()
	m := nextInt()

	head := make([]int32, n)
	for i := 0; i < n; i++ {
		head[i] = -1
	}
	to := make([]int32, 2*m)
	nxt := make([]int32, 2*m)
	wt := make([]uint8, 2*m)
	ec := 0
	addEdge := func(u, v, w int) {
		to[ec] = int32(v)
		wt[ec] = uint8(w)
		nxt[ec] = head[u]
		head[u] = int32(ec)
		ec++
	}

	for i := 0; i < m; i++ {
		u := nextInt() - 1
		v := nextInt() - 1
		w := nextInt()
		addEdge(u, v, w)
		addEdge(v, u, w)
	}

	const Layers int32 = 51
	states := n * int(Layers)
	const INF int64 = 1 << 60

	dist := make([]int64, states)
	for i := 0; i < states; i++ {
		dist[i] = INF
	}
	pos := make([]int32, states)

	h := MinHeap{
		a:    make([]int32, 1, states+1),
		pos:  pos,
		dist: dist,
	}

	var sq [101]int64
	for i := 0; i <= 100; i++ {
		sq[i] = int64(i * i)
	}

	dist[0] = 0
	h.Push(0)

	for h.Len() > 0 {
		s := h.Pop()
		d := dist[s]
		v := int(s / Layers)
		last := int(s % Layers)

		if last == 0 {
			for e := head[v]; e != -1; e = nxt[e] {
				ns := to[e]*Layers + int32(wt[e])
				if d < dist[ns] {
					pp := pos[ns]
					if pp == 0 {
						dist[ns] = d
						h.Push(ns)
					} else if pp > 0 {
						dist[ns] = d
						h.Decrease(ns)
					}
				}
			}
		} else {
			for e := head[v]; e != -1; e = nxt[e] {
				nd := d + sq[last+int(wt[e])]
				ns := to[e] * Layers
				if nd < dist[ns] {
					pp := pos[ns]
					if pp == 0 {
						dist[ns] = nd
						h.Push(ns)
					} else if pp > 0 {
						dist[ns] = nd
						h.Decrease(ns)
					}
				}
			}
		}
	}

	out := make([]byte, 0, n*12)
	for i := 0; i < n; i++ {
		if i > 0 {
			out = append(out, ' ')
		}
		d := dist[i*int(Layers)]
		if d == INF {
			out = append(out, '-', '1')
		} else {
			out = strconv.AppendInt(out, d, 10)
		}
	}
	out = append(out, '\n')
	os.Stdout.Write(out)
}