package main

import (
	"bufio"
	"fmt"
	"math/rand"
	"os"
	"time"
)

var in *bufio.Reader
var out *bufio.Writer
var rnd *rand.Rand
var queries int

func ask(x int, s []int) int {
	fmt.Fprint(out, "? ", x, " ", len(s))
	for _, v := range s {
		fmt.Fprint(out, " ", v)
	}
	fmt.Fprintln(out)
	out.Flush()
	queries++
	var resp int
	if _, err := fmt.Fscan(in, &resp); err != nil {
		os.Exit(0)
	}
	if resp == -1 {
		os.Exit(0)
	}
	return resp
}

func answer(y int) {
	fmt.Fprintf(out, "! %d\n", y)
	out.Flush()
}

func split(base []int, k int) ([]int, []int) {
	n := len(base)
	if k < 0 {
		k = 0
	}
	if k > n {
		k = n
	}
	p := rnd.Perm(n)
	a := make([]int, k)
	b := make([]int, n-k)
	for i, id := range p {
		if i < k {
			a[i] = base[id]
		} else {
			b[i-k] = base[id]
		}
	}
	return a, b
}

func main() {
	in = bufio.NewReaderSize(os.Stdin, 1<<20)
	out = bufio.NewWriterSize(os.Stdout, 1<<20)
	rnd = rand.New(rand.NewSource(time.Now().UnixNano()))

	var t int
	if _, err := fmt.Fscan(in, &t); err != nil {
		return
	}

	for ; t > 0; t-- {
		var n int
		if _, err := fmt.Fscan(in, &n); err != nil {
			return
		}
		if n == -1 {
			return
		}

		m := 2*n - 1
		all := make([]int, m)
		for i := 0; i < m; i++ {
			all[i] = i + 1
		}

		queries = 0

		rootK := m / 2
		A, B := split(all, rootK)

		ansA := make([]byte, n+1)
		ansB := make([]byte, n+1)
		yesA := make([]int, 0, n)

		for x := 1; x <= n; x++ {
			r := ask(x, A)
			ansA[x] = byte(r)
			if r == 1 {
				yesA = append(yesA, x)
			}
		}

		for _, x := range yesA {
			r := ask(x, B)
			ansB[x] = byte(r)
		}

		cnt10, cnt11, cnt01 := 0, 0, 0
		for x := 1; x <= n; x++ {
			if ansA[x] == 0 {
				cnt01++
			} else if ansB[x] == 1 {
				cnt11++
			} else {
				cnt10++
			}
		}

		inA := 2*cnt10 - len(A) + cnt11

		var T []int
		U := make([]int, 0, n)

		if inA == 1 {
			T = A
			for x := 1; x <= n; x++ {
				if ansA[x] == 1 && ansB[x] == 0 {
					U = append(U, x)
				}
			}
		} else {
			T = B
			for x := 1; x <= n; x++ {
				if ansA[x] == 0 {
					U = append(U, x)
				}
			}
		}

		optK := int(float64(len(T))*0.4142135623730951 + 0.5)
		if optK < 1 {
			optK = 1
		}
		if optK >= len(T) {
			optK = len(T) - 1
		}

		for len(U) > 1 {
			if optK <= 0 || queries+2*len(U) > 925 {
				break
			}
			R, C := split(T, optK)

			keep := make([]int, 0, len(U))
			yes := make([]int, 0, len(U))

			for _, x := range U {
				r := ask(x, R)
				if r == 0 {
					keep = append(keep, x)
				} else {
					yes = append(yes, x)
				}
			}

			for _, x := range yes {
				r := ask(x, C)
				if r == 0 {
					keep = append(keep, x)
				}
			}

			U = keep
		}

		if len(U) == 1 {
			answer(U[0])
			continue
		}

		if len(U) == 0 {
			answer(1)
			continue
		}

		rem := 925 - queries
		if rem > 0 && len(T) > 1 {
			half := len(T) / 2
			if half < 1 {
				half = 1
			}
			if half >= len(T) {
				half = len(T) - 1
			}
			rounds := rem / len(U)
			if rounds > 0 {
				scores := make([]int, len(U))
				for r := 0; r < rounds; r++ {
					R, _ := split(T, half)
					for i, x := range U {
						if ask(x, R) == 1 {
							scores[i]++
						}
					}
				}
				best := 0
				for i := 1; i < len(U); i++ {
					if scores[i] < scores[best] || (scores[i] == scores[best] && rnd.Intn(2) == 0) {
						best = i
					}
				}
				answer(U[best])
				continue
			}
		}

		answer(U[rnd.Intn(len(U))])
	}
}