```go
package main

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

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

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

	for tc := 0; tc < t; tc++ {
		var n, q int
		fmt.Fscan(reader, &n, &q)

		maxR := make([]int, n+2)
		for i := 0; i < q; i++ {
			var l, r int
			fmt.Fscan(reader, &l, &r)
			if r > maxR[l] {
				maxR[l] = r
			}
		}

		for i := 1; i <= n; i++ {
			if maxR[i-1] > maxR[i] {
				maxR[i] = maxR[i-1]
			}
		}

		type pair struct {
			l, r int
		}
		memo := make(map[pair]int)

		query := func(l, r int) int {
			p := pair{l, r}
			if val, ok := memo[p]; ok {
				return val
			}
			fmt.Fprintf(writer, "? %d %d\n", l, r)
			writer.Flush()
			var res int
			fmt.Fscan(reader, &res)
			if res == -1 {
				os.Exit(0)
			}
			memo[p] = res
			return res
		}

		check := func(X int) bool {
			low := 1
			high := n
			for low < high {
				mid := low + (high-low+1)/2
				if query(mid, n) >= X {
					low = mid
				} else {
					high = mid - 1
				}
			}
			L := low

			low = L
			high = n
			for low < high {
				mid := low + (high-low)/2
				if query(1, mid) >= X {
					high = mid
				} else {
					low = mid + 1
				}
			}
			R := low

			return maxR[L] >= R
		}

		ansLow := 0
		ansHigh := n
		for ansLow < ansHigh {
			mid := ansLow + (ansHigh-ansLow+1)/2
			if check(mid) {
				ansLow = mid
			} else {
				ansHigh = mid - 1
			}
		}

		fmt.Fprintf(writer, "! %d\n", ansLow)
		writer.Flush()
	}
}
```