fn main() {
    let t = read();
    for _ in 0..t {
        solve();
    }
}

fn solve() {
    let n = read();
    //rand() % 10 + 2;
    let mut solver = Oracle::new(n);
    let mut l = 0;
    let mut r = n;
    while r - l >= 2 {
        let x = solver.find(l, r);
        if r - l == 2 {
            l = l ^ x ^ (l + 1);
            break;
        }
        if r - l == 3 {
            if x == l {
                if solver.find(l, l + 2) == x {
                    l = l + 1;
                } else {
                    l = l + 2;
                }
            } else if x == l + 1 {
                if solver.find(l, l + 2) == x {
                    // l = l;
                } else {
                    l = r - 1;
                }
            } else {
                if solver.find(l + 1, r) == x {
                    l = x - 1;
                } else {
                    // l = l
                }
            }
            break;
        }
        let p = [l, (3 * l + r) / 4, (l + r) / 2, (l + 3 * r) / 4, r];
        let mut pos = p.iter().position(|p| x < *p).unwrap();
        if pos <= 2 {
            if solver.find(p[0], p[2]) == x {
                if p[pos - 1] + 2 <= p[pos] {
                    if solver.find(p[pos - 1], p[pos]) == x {
                    } else {
                        if pos == 1 {
                            pos += 1;
                        } else {
                            pos -= 1;
                        }
                    }
                    l = p[pos - 1];
                    r = p[pos];
                } else {
                    l = p[0];
                    r = p[2];
                }
            } else {
                if solver.find(p[pos - 1], p[3]) == x {
                    pos = 3;
                } else {
                    pos = 4;
                }
                l = p[pos - 1];
                r = p[pos];
            }
        } else {
            if solver.find(p[2], p[4]) == x {
                if p[pos - 1] + 2 <= p[pos] {
                    if solver.find(p[pos - 1], p[pos]) == x {
                    } else {
                        if pos == 3 {
                            pos += 1;
                        } else {
                            pos -= 1;
                        }
                    }
                    l = p[pos - 1];
                    r = p[pos];
                } else {
                    l = p[2];
                    r = p[4];
                }
            } else {
                if solver.find(p[1], p[pos]) == x {
                    pos = 2;
                } else {
                    pos = 1;
                }
                l = p[pos - 1];
                r = p[pos];
            }
        }
    }
    if !solver.answer(l) {
        println!("ERROR: {:?}", solver.p);
        println!("{} {} {}", solver.sum, solver.cnt, l);
        assert!(false);
    }
}

fn read() -> usize {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().parse().unwrap()
}

struct Oracle {
    p: Vec<usize>,
    sum: usize,
    cnt: usize,
}

impl Oracle {
    fn new(n: usize) -> Self {
        let mut p = (0..n).collect::<Vec<_>>();
        shuffle(&mut p);
        Self { p, sum: 0, cnt: 0 }
    }
    fn find(&mut self, l: usize, r: usize) -> usize {
        assert!(l + 2 <= r && r <= self.p.len(), "{l} {r}");
        self.sum += r - l;
        self.cnt += 1;
        println!("? {} {}", l + 1, r);
        read() - 1
        /*
        let mut x = (l..r).collect::<Vec<_>>();
        x.sort_by_key(|x| self.p[*x]);
        x[x.len() - 2]
        */
    }
    fn answer(&self, x: usize) -> bool {
        println!("! {}", x + 1);
        true
        /*
        let c = (1.5 * (self.p.len() as f64).log2()).ceil() as usize;
        self.p[x] == self.p.len() - 1 && self.cnt <= c && self.sum <= 3 * self.p.len()
        */
    }
}

fn rand_memory() -> usize {
    Box::into_raw(Box::new("I hope this is a random number")) as usize
}

fn rand() -> usize {
    static mut X: usize = 0;
    unsafe {
        if X == 0 {
            X = rand_memory();
        }
        X ^= X << 13;
        X ^= X >> 17;
        X ^= X << 5;
        X
    }
}

fn shuffle<T>(a: &mut [T]) {
    for i in 1..a.len() {
        let p = rand() % (i + 1);
        a.swap(i, p);
    }
}