For problem statement at 1000-1999/1600-1699/1620-1629/1622/problemF.txt this is a correct solution, but verifier at 1000-1999/1600-1699/1620-1629/1622/verifierF.go ends with test 6 failed
input:
6
expected:4
1 3 5 6
got:4
1 4 5 6

exit status 1 can you fix the verifier? package main

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

type Key struct {
	a uint64
	b uint64
}

func splitmix64(x uint64) uint64 {
	x += 0x9e3779b97f4a7c15
	z := x
	z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9
	z = (z ^ (z >> 27)) * 0x94d049bb133111eb
	return z ^ (z >> 31)
}

func verify(cands []int, target []uint64, primes []int) bool {
	tmp := make([]uint64, len(target))
	for _, t := range cands {
		if t <= 1 {
			continue
		}
		for idx, p := range primes {
			if p > t {
				break
			}
			q := t / p
			parity := 0
			for q > 0 {
				parity ^= q & 1
				q /= p
			}
			if parity == 1 {
				tmp[idx>>6] ^= uint64(1) << uint(idx&63)
			}
		}
	}
	for i := range target {
		if tmp[i] != target[i] {
			return false
		}
	}
	return true
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	var n int
	fmt.Fscan(in, &n)

	spf := make([]int32, n+1)
	primes := make([]int, 0, 80000)
	for i := 2; i <= n; i++ {
		if spf[i] == 0 {
			spf[i] = int32(i)
			primes = append(primes, i)
		}
		for _, p := range primes {
			v := p * i
			if v > n {
				break
			}
			spf[v] = int32(p)
			if p == int(spf[i]) {
				break
			}
		}
	}

	idxOf := make([]int32, n+1)
	for i, p := range primes {
		idxOf[p] = int32(i)
	}

	h1 := make([]uint64, len(primes))
	h2 := make([]uint64, len(primes))
	for i, p := range primes {
		x := splitmix64(uint64(p) + 0x123456789abcdef0)
		y := splitmix64(uint64(p) + 0xfedcba9876543210)
		if x == 0 && y == 0 {
			y = 1
		}
		h1[i] = x
		h2[i] = y
	}

	w := (len(primes) + 63) >> 6
	target := make([]uint64, w)
	prefix := make([]Key, n+1)
	var xhash Key
	par := n & 1

	for i := 2; i <= n; i++ {
		x := i
		var qi Key
		same := (i & 1) == par
		for x > 1 {
			p := int(spf[x])
			odd := 0
			for x%p == 0 {
				x /= p
				odd ^= 1
			}
			if odd == 1 {
				idx := int(idxOf[p])
				qi.a ^= h1[idx]
				qi.b ^= h2[idx]
				if same {
					target[idx>>6] ^= uint64(1) << uint(idx&63)
				}
			}
		}
		prefix[i] = Key{prefix[i-1].a ^ qi.a, prefix[i-1].b ^ qi.b}
		if same {
			xhash.a ^= qi.a
			xhash.b ^= qi.b
		}
	}

	zero := true
	for _, v := range target {
		if v != 0 {
			zero = false
			break
		}
	}

	var excl []int

	if !zero {
		for i := 2; i <= n; i++ {
			if prefix[i] == xhash && verify([]int{i}, target, primes) {
				excl = []int{i}
				break
			}
		}

		if len(excl) == 0 && n >= 3 {
			seen := make(map[Key]int, n)
			seen[prefix[2]] = 2
			for j := 3; j <= n; j++ {
				need := Key{prefix[j].a ^ xhash.a, prefix[j].b ^ xhash.b}
				if i, ok := seen[need]; ok {
					if verify([]int{i, j}, target, primes) {
						excl = []int{i, j}
						break
					}
				}
				if _, ok := seen[prefix[j]]; !ok {
					seen[prefix[j]] = j
				}
			}
		}

		if len(excl) == 0 {
			m := n / 2
			if n%2 == 0 {
				if m%2 == 0 {
					excl = []int{m}
				} else {
					excl = []int{2, m}
				}
			} else {
				if m%2 == 0 {
					excl = []int{m, n}
				} else {
					excl = []int{2, m, n}
				}
			}
		}
	}

	sort.Ints(excl)
	u := excl[:0]
	for _, x := range excl {
		if x <= 1 || x > n {
			continue
		}
		if len(u) == 0 || u[len(u)-1] != x {
			u = append(u, x)
		}
	}
	excl = u

	size := n - len(excl)
	out := make([]byte, 0, 8*size+32)
	out = strconv.AppendInt(out, int64(size), 10)
	out = append(out, '\n')

	ei := 0
	first := true
	for i := 1; i <= n; i++ {
		if ei < len(excl) && excl[ei] == i {
			ei++
			continue
		}
		if !first {
			out = append(out, ' ')
		} else {
			first = false
		}
		out = strconv.AppendInt(out, int64(i), 10)
	}
	out = append(out, '\n')

	os.Stdout.Write(out)
}