For problem statement at 1000-1999/1900-1999/1980-1989/1981/problemD.txt this is a correct solution, but verifier at 1000-1999/1900-1999/1980-1989/1981/verifierD.go ends with case 1 failed at position 3
expected: [2 2 5 5 3]
got: [2 2 3 3 5]
exit status 1 can you fix the verifier? ```go
package main

import (
	"bufio"
	"io"
	"os"
	"sort"
	"strconv"
)

func nextInt(data []byte, idx *int) int {
	n := len(data)
	i := *idx
	for i < n && (data[i] < '0' || data[i] > '9') {
		i++
	}
	val := 0
	for i < n && data[i] >= '0' && data[i] <= '9' {
		val = val*10 + int(data[i]-'0')
		i++
	}
	*idx = i
	return val
}

func capacity(k int) int {
	if k&1 == 1 {
		return k * (k + 1) / 2
	}
	return k*k/2 + 1
}

func generatePrimes(need int) []int {
	limit := 20000
	for {
		comp := make([]bool, limit+1)
		primes := make([]int, 0, need)
		for i := 2; i <= limit; i++ {
			if !comp[i] {
				primes = append(primes, i)
				if i*i <= limit {
					for j := i * i; j <= limit; j += i {
						comp[j] = true
					}
				}
			}
		}
		if len(primes) >= need {
			return primes
		}
		limit *= 2
	}
}

func buildTrail(k int) []int {
	ecap := capacity(k)
	adj := make([][]int, k)
	for i := 0; i < k; i++ {
		d := k
		if k%2 == 0 && k > 2 && i < k-2 {
			d = k - 1
		}
		adj[i] = make([]int, 0, d)
	}
	u := make([]int, 0, ecap)
	v := make([]int, 0, ecap)

	for i := 0; i < k; i++ {
		id := len(u)
		u = append(u, i)
		v = append(v, i)
		adj[i] = append(adj[i], id)
	}

	for i := 0; i < k; i++ {
		for j := i + 1; j < k; j++ {
			if k%2 == 0 && k > 2 && i < k-2 && i%2 == 0 && j == i+1 {
				continue
			}
			id := len(u)
			u = append(u, i)
			v = append(v, j)
			adj[i] = append(adj[i], id)
			adj[j] = append(adj[j], id)
		}
	}

	used := make([]bool, len(u))
	it := make([]int, k)
	start := 0
	if k%2 == 0 && k > 2 {
		start = k - 2
	}

	stack := make([]int, 1, len(u)+1)
	stack[0] = start
	path := make([]int, 0, len(u)+1)

	for len(stack) > 0 {
		x := stack[len(stack)-1]
		for it[x] < len(adj[x]) && used[adj[x][it[x]]] {
			it[x]++
		}
		if it[x] == len(adj[x]) {
			path = append(path, x)
			stack = stack[:len(stack)-1]
		} else {
			e := adj[x][it[x]]
			it[x]++
			if used[e] {
				continue
			}
			used[e] = true
			to := u[e] ^ v[e] ^ x
			stack = append(stack, to)
		}
	}

	return path
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	t := nextInt(data, &idx)
	tests := make([]int, t)
	maxNeed := 0
	for i := 0; i < t; i++ {
		tests[i] = nextInt(data, &idx)
		if tests[i]-1 > maxNeed {
			maxNeed = tests[i] - 1
		}
	}

	caps := make([]int, 0)
	for k := 1; ; k++ {
		c := capacity(k)
		caps = append(caps, c)
		if c >= maxNeed {
			break
		}
	}

	primes := generatePrimes(len(caps))

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	for _, n := range tests {
		need := n - 1
		k := sort.Search(len(caps), func(i int) bool { return caps[i] >= need }) + 1
		trail := buildTrail(k)
		m := len(trail)
		buf := make([]byte, 0, n*7)
		for i := 0; i < n; i++ {
			if i > 0 {
				buf = append(buf, ' ')
			}
			val := primes[trail[m-1-i]]
			buf = strconv.AppendInt(buf, int64(val), 10)
		}
		buf = append(buf, '\n')
		out.Write(buf)
	}
}
```