For problem statement at 1000-1999/1500-1599/1520-1529/1525/problemF.txt this is a correct solution, but verifier at 1000-1999/1500-1599/1520-1529/1525/verifierF.go ends with All tests passed can you fix the verifier? package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var n, m, k int
	if _, err := fmt.Fscan(reader, &n, &m, &k); err != nil {
		return
	}

	adj := make([][]int, n+1)
	for i := 0; i < m; i++ {
		var u, v int
		fmt.Fscan(reader, &u, &v)
		adj[u] = append(adj[u], v)
	}

	x := make([]int, k+1)
	y := make([]int, k+1)
	for i := 1; i <= k; i++ {
		fmt.Fscan(reader, &x[i], &y[i])
	}

	matchL := make([]int, n+1)
	matchR := make([]int, n+1)
	M := 0

	for i := 1; i <= n; i++ {
		used := make([]bool, n+1)
		var dfs func(u int) bool
		dfs = func(u int) bool {
			for _, v := range adj[u] {
				if used[v] {
					continue
				}
				used[v] = true
				if matchR[v] == 0 || dfs(matchR[v]) {
					matchR[v] = u
					matchL[u] = v
					return true
				}
			}
			return false
		}
		if dfs(i) {
			M++
		}
	}

	visitedL := make([]bool, n+1)
	visitedR := make([]bool, n+1)

	var dfsMVC func(u int)
	dfsMVC = func(u int) {
		visitedL[u] = true
		for _, v := range adj[u] {
			if !visitedR[v] {
				visitedR[v] = true
				if matchR[v] != 0 && !visitedL[matchR[v]] {
					dfsMVC(matchR[v])
				}
			}
		}
	}

	for i := 1; i <= n; i++ {
		if matchL[i] == 0 {
			dfsMVC(i)
		}
	}

	cover := make([]int, 0)
	for i := 1; i <= n; i++ {
		if matchL[i] != 0 && !visitedL[i] {
			cover = append(cover, i)
		}
	}
	for i := 1; i <= n; i++ {
		if visitedR[i] {
			cover = append(cover, -i)
		}
	}

	req := make([]int, k+1)
	for i := 1; i <= k; i++ {
		r := M - n + i + 1
		if r < 0 {
			r = 0
		}
		req[i] = r
	}

	dp := make([][]int64, k+1)
	parentJ := make([][]int, k+1)
	choiceT := make([][]int, k+1)
	for i := 0; i <= k; i++ {
		dp[i] = make([]int64, M+1)
		parentJ[i] = make([]int, M+1)
		choiceT[i] = make([]int, M+1)
		for j := 0; j <= M; j++ {
			dp[i][j] = -1
		}
	}
	dp[0][0] = 0

	for i := 1; i <= k; i++ {
		for j := 0; j <= M; j++ {
			if dp[i-1][j] == -1 {
				continue
			}
			for t := 0; j+t <= M; t++ {
				if j+t >= req[i] {
					score := int64(x[i]) - int64(t)*int64(y[i])
					if score < 0 {
						score = 0
					}
					if dp[i-1][j]+score > dp[i][j+t] {
						dp[i][j+t] = dp[i-1][j] + score
						parentJ[i][j+t] = j
						choiceT[i][j+t] = t
					}
				}
			}
		}
	}

	bestJ := -1
	var maxScore int64 = -1
	for j := req[k]; j <= M; j++ {
		if dp[k][j] > maxScore {
			maxScore = dp[k][j]
			bestJ = j
		}
	}

	tArr := make([]int, k+1)
	currJ := bestJ
	for i := k; i >= 1; i-- {
		tArr[i] = choiceT[i][currJ]
		currJ = parentJ[i][currJ]
	}

	fmt.Fprintln(writer, k+bestJ)
	coverIdx := 0
	for i := 1; i <= k; i++ {
		for step := 0; step < tArr[i]; step++ {
			fmt.Fprintf(writer, "%d ", cover[coverIdx])
			coverIdx++
		}
		fmt.Fprintf(writer, "0 ")
	}
	fmt.Fprintln(writer)
}