For problem statement at 2000-2999/2100-2199/2100-2109/2101/problemC.txt this is a correct solution, but verifier at 2000-2999/2100-2199/2100-2109/2101/verifierC.go ends with mismatch on test 4: expected 14, got 16 (n=8, a[:min(10)][1 5 2 8 4 1 4 2])
exit status 1 can you fix the verifier? ```go
package main

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

type Item struct {
	id       int
	deadline int
	weight   int
}

type DSU struct {
	parent []int
}

func NewDSU(n int) *DSU {
	p := make([]int, n+1)
	for i := range p {
		p[i] = i
	}
	return &DSU{p}
}

func (d *DSU) Find(x int) int {
	if d.parent[x] == x {
		return x
	}
	d.parent[x] = d.Find(d.parent[x])
	return d.parent[x]
}

func (d *DSU) Union(x, y int) {
	rootX := d.Find(x)
	rootY := d.Find(y)
	if rootX != rootY {
		d.parent[rootX] = rootY
	}
}

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

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

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

	for tc := 0; tc < t; tc++ {
		var n int
		fmt.Fscan(reader, &n)

		items := make([]Item, n)
		for i := 0; i < n; i++ {
			var a int
			fmt.Fscan(reader, &a)
			items[i] = Item{
				id:       i + 1,
				deadline: 2 * a,
				weight:   abs(2*(i+1) - n - 1),
			}
		}

		sort.Slice(items, func(i, j int) bool {
			if items[i].weight == items[j].weight {
				return items[i].id > items[j].id
			}
			return items[i].weight > items[j].weight
		})

		dsu := NewDSU(2 * n)
		accepted := make([]int, 0, n)

		for _, item := range items {
			d := item.deadline
			if d > 2*n {
				d = 2 * n
			}
			slot := dsu.Find(d)
			if slot > 0 {
				accepted = append(accepted, item.id)
				dsu.Union(slot, slot-1)
			}
		}

		sort.Ints(accepted)
		m := len(accepted)
		k := m / 2

		var profit int64 = 0
		for i := 0; i < k; i++ {
			profit -= int64(accepted[i])
		}
		for i := m - k; i < m; i++ {
			profit += int64(accepted[i])
		}

		fmt.Fprintln(writer, profit)
	}
}
```