For problem statement at 0-999/700-799/720-729/721/problemC.txt this is a correct solution, but verifier at 0-999/700-799/720-729/721/verifierC.go ends with All 105 tests passed can you fix the verifier? package main

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

type FastScanner struct {
	data []byte
	idx  int
}

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

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

	n := fs.nextInt()
	m := fs.nextInt()
	T := fs.nextInt()

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

	to := make([]int, m)
	wt := make([]uint32, m)
	next := make([]int, m)
	indeg := make([]int, n+1)

	for i := 0; i < m; i++ {
		u := fs.nextInt()
		v := fs.nextInt()
		t := fs.nextInt()
		to[i] = v
		wt[i] = uint32(t)
		next[i] = head[u]
		head[u] = i
		indeg[v]++
	}

	queue := make([]int, n)
	front, back := 0, 0
	for i := 1; i <= n; i++ {
		if indeg[i] == 0 {
			queue[back] = i
			back++
		}
	}

	order := make([]int, 0, n)
	for front < back {
		u := queue[front]
		front++
		order = append(order, u)
		for e := head[u]; e != -1; e = next[e] {
			v := to[e]
			indeg[v]--
			if indeg[v] == 0 {
				queue[back] = v
				back++
			}
		}
	}

	cols := n + 1
	size := cols * cols

	dp := make([]uint32, size)
	parent := make([]uint16, size)
	base := make([]int, n+1)
	for i := 1; i <= n; i++ {
		base[i] = i * cols
	}

	dp[base[1]+1] = 1
	limit := uint32(T) + 1

	for _, u := range order {
		bu := base[u]
		for l := 1; l < n; l++ {
			cur := dp[bu+l]
			if cur == 0 {
				continue
			}
			for e := head[u]; e != -1; e = next[e] {
				cand := cur + wt[e]
				if cand > limit {
					continue
				}
				pos := base[to[e]] + l + 1
				if dp[pos] == 0 || cand < dp[pos] {
					dp[pos] = cand
					parent[pos] = uint16(u)
				}
			}
		}
	}

	k := 0
	bn := base[n]
	for l := n; l >= 1; l-- {
		if dp[bn+l] != 0 {
			k = l
			break
		}
	}

	path := make([]int, k)
	cur := n
	for l := k; l >= 1; l-- {
		path[l-1] = cur
		if l > 1 {
			cur = int(parent[base[cur]+l])
		}
	}

	var out bytes.Buffer
	out.WriteString(strconv.Itoa(k))
	out.WriteByte('\n')
	for i, v := range path {
		if i > 0 {
			out.WriteByte(' ')
		}
		out.WriteString(strconv.Itoa(v))
	}
	out.WriteByte('\n')
	os.Stdout.Write(out.Bytes())
}