package main

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

type Node struct {
	adj      []int
	parent   int
	children []int
	in, out  int
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var t int
	if _, err := fmt.Fscan(reader, &t); err != nil {
		return
	}
	for i := 0; i < t; i++ {
		solve(reader)
	}
}

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

	nodes := make([]Node, n+1)
	for i := 1; i <= n; i++ {
		nodes[i].adj = make([]int, 0)
		nodes[i].children = make([]int, 0)
	}

	for i := 0; i < n-1; i++ {
		var u, v int
		fmt.Fscan(reader, &u, &v)
		nodes[u].adj = append(nodes[u].adj, v)
		nodes[v].adj = append(nodes[v].adj, u)
	}

	if n == 1 {
		fmt.Println("! 1")
		return
	}

	timer := 0
	var dfs func(int, int)
	dfs = func(u, p int) {
		timer++
		nodes[u].in = timer
		nodes[u].parent = p
		for _, v := range nodes[u].adj {
			if v != p {
				nodes[u].children = append(nodes[u].children, v)
				dfs(v, u)
			}
		}
		nodes[u].out = timer
	}

	dfs(1, 0)
	nodes[1].parent = 1

	S := make([]int, 0, n)
	in_S := make([]bool, n+1)
	for i := 1; i <= n; i++ {
		S = append(S, i)
		in_S[i] = true
	}

	inSubtree := func(x, v int) bool {
		return nodes[v].in <= nodes[x].in && nodes[x].in <= nodes[v].out
	}

	total_in_S := make([]int, n+1)
	C_in := make([]int, n+1)
	S_1 := make([]int, n+1)

	for len(S) > 1 {
		for i := 0; i <= n; i++ {
			total_in_S[i] = 0
			C_in[i] = 0
			S_1[i] = 0
		}

		for _, x := range S {
			total_in_S[nodes[x].parent]++
		}

		C := 0
		for i := 1; i <= n; i++ {
			if total_in_S[i] > 0 {
				C++
			}
		}

		var compute func(int)
		compute = func(u int) {
			if total_in_S[u] > 0 {
				C_in[u] = 1
			}
			if in_S[u] {
				S_1[u] = 1
			}
			for _, v := range nodes[u].children {
				compute(v)
				C_in[u] += C_in[v]
				S_1[u] += S_1[v]
			}
		}
		compute(1)

		best_v := -1
		best_score := n + 2
		best_tie := n + 2

		for v := 2; v <= n; v++ {
			val := 0
			if in_S[v] && total_in_S[nodes[v].parent] == 1 {
				val = 1
			}
			S_0_v := C - C_in[v] - val
			score := S_1[v]
			if S_0_v > score {
				score = S_0_v
			}
			tie := S_1[v] + S_0_v

			if score < best_score || (score == best_score && tie < best_tie) {
				best_score = score
				best_tie = tie
				best_v = v
			}
		}

		fmt.Printf("? %d\n", best_v)
		var ans int
		fmt.Fscan(reader, &ans)

		new_S := make([]int, 0)
		new_in_S := make([]bool, n+1)

		if ans == 1 {
			for _, x := range S {
				if inSubtree(x, best_v) {
					new_S = append(new_S, x)
					new_in_S[x] = true
				}
			}
		} else {
			for _, x := range S {
				if !inSubtree(x, best_v) {
					p := nodes[x].parent
					if !new_in_S[p] {
						new_S = append(new_S, p)
						new_in_S[p] = true
					}
				}
			}
		}
		S = new_S
		in_S = new_in_S
	}

	fmt.Printf("! %d\n", S[0])
}