For problem statement at 1000-1999/1400-1499/1490-1499/1497/problemE2.txt this is a correct solution, but verifier at 1000-1999/1400-1499/1490-1499/1497/verifierE2.go ends with All 100 tests passed can you fix the verifier? ```go
package main

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

var data []byte
var ptr int
var primes []int
var memo map[int]int

func nextInt() int {
	for ptr < len(data) {
		b := data[ptr]
		if b >= '0' && b <= '9' {
			break
		}
		ptr++
	}
	n := 0
	for ptr < len(data) {
		b := data[ptr]
		if b < '0' || b > '9' {
			break
		}
		n = n*10 + int(b-'0')
		ptr++
	}
	return n
}

func buildPrimes(limit int) []int {
	isComp := make([]bool, limit+1)
	res := make([]int, 0, 500)
	for i := 2; i <= limit; i++ {
		if !isComp[i] {
			res = append(res, i)
			if i*i <= limit {
				for j := i * i; j <= limit; j += i {
					isComp[j] = true
				}
			}
		}
	}
	return res
}

func kernel(x int) int {
	if v, ok := memo[x]; ok {
		return v
	}
	y := x
	res := 1
	for _, p := range primes {
		if p*p > y {
			break
		}
		if y%p == 0 {
			odd := 0
			for y%p == 0 {
				y /= p
				odd ^= 1
			}
			if odd == 1 {
				res *= p
			}
		}
	}
	if y > 1 {
		res *= y
	}
	memo[x] = res
	return res
}

func main() {
	data, _ = io.ReadAll(os.Stdin)
	primes = buildPrimes(3162)
	memo = make(map[int]int, 300000)
	memo[1] = 1

	t := nextInt()
	out := make([]byte, 0, t*4)

	var arr []int
	var nxt []int
	var dp []int

	for ; t > 0; t-- {
		n := nextInt()
		k := nextInt()

		if cap(arr) < n {
			arr = make([]int, n)
		} else {
			arr = arr[:n]
		}

		id := make(map[int]int, n*2)
		m := 0
		for i := 0; i < n; i++ {
			v := kernel(nextInt())
			if idx, ok := id[v]; ok {
				arr[i] = idx
			} else {
				id[v] = m
				arr[i] = m
				m++
			}
		}

		stride := k + 1
		size := (n + 1) * stride

		if cap(nxt) < size {
			nxt = make([]int, size)
		} else {
			nxt = nxt[:size]
		}
		if cap(dp) < size {
			dp = make([]int, size)
		} else {
			dp = dp[:size]
		}

		for c := 0; c <= k; c++ {
			cnt := make([]int, m)
			dup, r := 0, 0
			base := 0
			for l := 0; l < n; l++ {
				for r < n {
					v := arr[r]
					if cnt[v] > 0 {
						if dup == c {
							break
						}
						dup++
					}
					cnt[v]++
					r++
				}
				nxt[base+c] = r
				v := arr[l]
				if cnt[v] > 1 {
					dup--
				}
				cnt[v]--
				base += stride
			}
			nxt[n*stride+c] = n
		}

		baseN := n * stride
		for j := 0; j <= k; j++ {
			dp[baseN+j] = 0
		}

		for i, base := n-1, (n-1)*stride; i >= 0; i, base = i-1, base-stride {
			for j := 0; j <= k; j++ {
				best := n + 1
				for c := 0; c <= j; c++ {
					ni := nxt[base+c]
					v := dp[ni*stride+j-c] + 1
					if v < best {
						best = v
					}
				}
				dp[base+j] = best
			}
		}

		out = strconv.AppendInt(out, int64(dp[k]), 10)
		out = append(out, '\n')
	}

	_, _ = os.Stdout.Write(out)
}
```