```go
package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

type Item struct {
	val uint64
	pos int
}

type Group struct {
	L []Item
	R []Item
}

type Cnt struct {
	l0, l1 int
	r0, r1 int
}

func nextUint64(data []byte, idx *int) uint64 {
	n := len(data)
	for *idx < n {
		c := data[*idx]
		if c >= '0' && c <= '9' {
			break
		}
		*idx++
	}
	var x uint64
	for *idx < n {
		c := data[*idx]
		if c < '0' || c > '9' {
			break
		}
		x = x*10 + uint64(c-'0')
		*idx++
	}
	return x
}

func findPairs(even, odd []Item, bits int) (Item, Item, Item, Item, bool) {
	groups := []Group{{L: even, R: odd}}
	for bit := bits - 1; bit >= 0; bit-- {
		mask := uint64(1) << bit
		cnts := make([]Cnt, len(groups))
		var count0, count1 int64
		for i, g := range groups {
			var c Cnt
			for _, it := range g.L {
				if it.val&mask == 0 {
					c.l0++
				} else {
					c.l1++
				}
			}
			for _, it := range g.R {
				if it.val&mask == 0 {
					c.r0++
				} else {
					c.r1++
				}
			}
			cnts[i] = c
			count0 += int64(c.l0)*int64(c.r0) + int64(c.l1)*int64(c.r1)
			count1 += int64(c.l0)*int64(c.r1) + int64(c.l1)*int64(c.r0)
		}
		threshold := int64(1) << bit
		h := 0
		if count0 <= threshold {
			h = 1
		}
		newGroups := make([]Group, 0, len(groups)*2)
		for i, g := range groups {
			c := cnts[i]
			if h == 0 {
				var lA, lB, rA, rB []Item
				if c.l0 > 0 && c.r0 > 0 {
					lA = make([]Item, 0, c.l0)
					rA = make([]Item, 0, c.r0)
				}
				if c.l1 > 0 && c.r1 > 0 {
					lB = make([]Item, 0, c.l1)
					rB = make([]Item, 0, c.r1)
				}
				for _, it := range g.L {
					if it.val&mask == 0 {
						if lA != nil {
							lA = append(lA, it)
						}
					} else {
						if lB != nil {
							lB = append(lB, it)
						}
					}
				}
				for _, it := range g.R {
					if it.val&mask == 0 {
						if rA != nil {
							rA = append(rA, it)
						}
					} else {
						if rB != nil {
							rB = append(rB, it)
						}
					}
				}
				if len(lA) > 0 && len(rA) > 0 {
					newGroups = append(newGroups, Group{L: lA, R: rA})
				}
				if len(lB) > 0 && len(rB) > 0 {
					newGroups = append(newGroups, Group{L: lB, R: rB})
				}
			} else {
				var lA, lB, rA, rB []Item
				if c.l0 > 0 && c.r1 > 0 {
					lA = make([]Item, 0, c.l0)
					rA = make([]Item, 0, c.r1)
				}
				if c.l1 > 0 && c.r0 > 0 {
					lB = make([]Item, 0, c.l1)
					rB = make([]Item, 0, c.r0)
				}
				for _, it := range g.L {
					if it.val&mask == 0 {
						if lA != nil {
							lA = append(lA, it)
						}
					} else {
						if lB != nil {
							lB = append(lB, it)
						}
					}
				}
				for _, it := range g.R {
					if it.val&mask == 0 {
						if rB != nil {
							rB = append(rB, it)
						}
					} else {
						if rA != nil {
							rA = append(rA, it)
						}
					}
				}
				if len(lA) > 0 && len(rA) > 0 {
					newGroups = append(newGroups, Group{L: lA, R: rA})
				}
				if len(lB) > 0 && len(rB) > 0 {
					newGroups = append(newGroups, Group{L: lB, R: rB})
				}
			}
		}
		groups = newGroups
	}
	var a, b, c, d Item
	foundFirst := false
	for _, g := range groups {
		x := len(g.L)
		y := len(g.R)
		if x == 0 || y == 0 {
			continue
		}
		if !foundFirst {
			a, b = g.L[0], g.R[0]
			foundFirst = true
			if x*y > 1 {
				if x >= 2 {
					c, d = g.L[1], g.R[0]
				} else {
					c, d = g.L[0], g.R[1]
				}
				return a, b, c, d, true
			}
		} else {
			c, d = g.L[0], g.R[0]
			return a, b, c, d, true
		}
	}
	return Item{}, Item{}, Item{}, Item{}, false
}

func buildAnswer(p1a, p1b, p2a, p2b int) (int, int, int, int) {
	l1, r1 := p1a, p1b
	if l1 > r1 {
		l1, r1 = r1, l1
	}
	l2, r2 := p2a, p2b
	if l2 > r2 {
		l2, r2 = r2, l2
	}
	if r1 <= l2 || r2 <= l1 {
		return l1 + 1, r1, l2 + 1, r2
	}
	if l1 == l2 {
		if r1 > r2 {
			r1, r2 = r2, r1
		}
		return r1 + 1, r1 + 1, r1 + 2, r2
	}
	if r1 == r2 {
		if l1 > l2 {
			l1, l2 = l2, l1
		}
		return l1 + 1, l1 + 1, l1 + 2, l2
	}
	if l1 > l2 {
		l1, l2 = l2, l1
		r1, r2 = r2, r1
	}
	if r1 < r2 {
		return l1 + 1, l2, r1 + 1, r2
	}
	return l1 + 1, l2, r2 + 1, r1
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	t := int(nextUint64(data, &idx))
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	for ; t > 0; t-- {
		k := int(nextUint64(data, &idx))
		n := 1 << (k + 1)
		m := n >> 1

		even := make([]Item, 0, m+1)
		odd := make([]Item, 0, m)
		var pref uint64
		even = append(even, Item{val: 0, pos: 0})
		for i := 1; i <= n; i++ {
			pref ^= nextUint64(data, &idx)
			if i&1 == 0 {
				even = append(even, Item{val: pref, pos: i})
			} else {
				odd = append(odd, Item{val: pref, pos: i})
			}
		}

		a, b, c, d, ok := findPairs(even, odd, 2*k)
		if !ok {
			fmt.Fprintln(out, -1)
			continue
		}
		x1, y1, x2, y2 := buildAnswer(a.pos, b.pos, c.pos, d.pos)
		fmt.Fprintln(out, x1, y1, x2, y2)
	}
}
```