```go
package main

import (
	"bufio"
	"fmt"
	"io"
	"math/bits"
	"os"
	"sort"
)

type SegTree struct {
	size int
	data []int
}

func NewSegTree(n int) *SegTree {
	size := 1
	for size < n {
		size <<= 1
	}
	data := make([]int, 2*size)
	return &SegTree{size: size, data: data}
}

func (st *SegTree) Update(idx int, val int) {
	p := idx + st.size
	if st.data[p] == val {
		return
	}
	st.data[p] = val
	for p >>= 1; p >= 1; p >>= 1 {
		lc, rc := p<<1, (p<<1)|1
		if st.data[lc] >= st.data[rc] {
			st.data[p] = st.data[lc]
		} else {
			st.data[p] = st.data[rc]
		}
	}
}

func (st *SegTree) Query(l, r int) int {
	if l > r {
		return 0
	}
	l += st.size
	r += st.size
	res := 0
	for l <= r {
		if (l & 1) == 1 {
			if st.data[l] > res {
				res = st.data[l]
			}
			l++
		}
		if (r & 1) == 0 {
			if st.data[r] > res {
				res = st.data[r]
			}
			r--
		}
		l >>= 1
		r >>= 1
	}
	return res
}

func lowerBound(a []int, x int) int {
	return sort.Search(len(a), func(i int) bool { return a[i] >= x })
}
func upperBound(a []int, x int) int {
	return sort.Search(len(a), func(i int) bool { return a[i] > x })
}

type Pair struct {
	l int
	r int
}

func decomposeRange(l, r int) []Pair {
	var res []Pair
	cur := l
	for cur <= r {
		size1 := int(uint(cur) & -uint(cur))
		if size1 == 0 {
			size1 = 1 << 30
		}
		remain := r - cur + 1
		size2 := 1 << (bits.Len(uint(remain)) - 1)
		size := size1
		if size2 < size {
			size = size2
		}
		res = append(res, Pair{cur, cur + size - 1})
		cur += size
	}
	return res
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	pos := 0
	nextInt := func() int {
		n := len(data)
		for pos < n && (data[pos] < '0' || data[pos] > '9') && data[pos] != '-' {
			pos++
		}
		sign := 1
		if pos < n && data[pos] == '-' {
			sign = -1
			pos++
		}
		val := 0
		for pos < n && data[pos] >= '0' && data[pos] <= '9' {
			val = val*10 + int(data[pos]-'0')
			pos++
		}
		return val * sign
	}

	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	t := nextInt()
	for ; t > 0; t-- {
		n := nextInt()
		k := nextInt()
		a := make([]int, n)
		for i := 0; i < n; i++ {
			a[i] = nextInt()
		}
		if k == 0 {
			fmt.Fprintln(out, 1)
			continue
		}
		h := bits.Len(uint(k)) - 1
		M := 1 << h
		rem := k - M

		diffAdj := false
		for i := 1; i < n; i++ {
			if (a[i]>>(h+1)) != (a[i-1]>>(h+1)) {
				diffAdj = true
				break
			}
		}
		if diffAdj {
			fmt.Fprintln(out, 2)
			continue
		}

		// All P are equal across array
		// Prepare groups by bit h and low values
		vals := [2][]int{}
		bitsH := make([]int, n)
		lows := make([]int, n)
		for i := 0; i < n; i++ {
			b := (a[i] >> h) & 1
			bitsH[i] = b
			low := a[i] & (M - 1)
			lows[i] = low
			vals[b] = append(vals[b], low)
		}
		for g := 0; g < 2; g++ {
			if len(vals[g]) > 0 {
				sort.Ints(vals[g])
				// unique
				j := 1
				for i := 1; i < len(vals[g]); i++ {
					if vals[g][i] != vals[g][i-1] {
						vals[g][j] = vals[g][i]
						j++
					}
				}
				vals[g] = vals[g][:j]
			}
		}

		// If one group empty, no pair possible
		if len(vals[0]) == 0 || len(vals[1]) == 0 {
			fmt.Fprintln(out, -1)
			continue
		}

		st := [2]*SegTree{NewSegTree(len(vals[0])), NewSegTree(len(vals[1]))}

		ans := n + 1
		blocks := decomposeRange(rem, M-1)

		for j := 0; j < n; j++ {
			y := lows[j]
			b := bitsH[j]
			opp := 1 - b
			best := 0
			for _, bl := range blocks {
				lz := bl.l ^ y
				rz := bl.r ^ y
				// These are dyadic intervals; we must ensure lz <= rz (always true as size preserves and XOR maps to aligned block)
				li := lowerBound(vals[opp], lz)
				ri := upperBound(vals[opp], rz) - 1
				if li <= ri {
					v := st[opp].Query(li, ri)
					if v > best {
						best = v
					}
				}
			}
			if best > 0 {
				// indices are 1-based for length calculation: store positions as 1-based
				L := j + 1 - best + 1
				if L < ans {
					ans = L
				}
			}
			// update current group's segment tree with this position (store 1-based index)
			idx := lowerBound(vals[b], y)
			st[b].Update(idx, j+1)
		}

		if ans == n+1 {
			fmt.Fprintln(out, -1)
		} else {
			fmt.Fprintln(out, ans)
		}
	}
}
```