package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var t int
	fmt.Fscan(reader, &t)
	for i := 0; i < t; i++ {
		solve(reader, writer)
	}
}

type Item struct {
	L, R, fL, fR int64
}

func solve(reader *bufio.Reader, writer *bufio.Writer) {
	var n int64
	fmt.Fscan(reader, &n)

	query := func(x int64) int64 {
		fmt.Fprintf(writer, "xor 1 %d\n", x)
		writer.Flush()
		var res int64
		fmt.Fscan(reader, &res)
		if res == -1 {
			os.Exit(0)
		}
		return res
	}

	S := query(n)

	pos := make(map[int64]int64)
	M := []int64{}

	addVal := func(x, val int64) {
		if val != 0 && val != S {
			if _, exists := pos[val]; !exists {
				pos[val] = x
				M = append(M, val)
			}
		}
	}

	queue := []Item{}

	if S == 0 {
		last_x := n
		last_val := int64(0)
		for k := 60; k >= 1; k-- {
			x := (int64(1) << k) - int64(1)
			if x >= n {
				continue
			}
			val := query(x)
			addVal(x, val)
			if val != 0 {
				queue = append(queue, Item{0, x, 0, val})
				queue = append(queue, Item{x, last_x, val, 0})
				break
			}
			last_x = x
			last_val = val
			_ = last_val 
		}
	} else {
		queue = append(queue, Item{0, n, 0, S})
	}

	for len(queue) > 0 && len(M) < 2 {
		item := queue[0]
		queue = queue[1:]

		if item.fL == item.fR {
			continue
		}
		if item.R-item.L <= 1 {
			continue
		}

		mid := item.L + (item.R-item.L)/2
		val := query(mid)
		addVal(mid, val)

		if len(M) >= 2 {
			break
		}

		queue = append(queue, Item{item.L, mid, item.fL, val})
		queue = append(queue, Item{mid, item.R, val, item.fR})
	}

	v1 := M[0]
	v2 := M[1]
	if pos[v1] > pos[v2] {
		v1, v2 = v2, v1
	}

	a := v1
	b := v1 ^ v2
	c := v2 ^ S

	fmt.Fprintf(writer, "ans %d %d %d\n", a, b, c)
	writer.Flush()
}