use std::io;
use std::io::BufRead;
use std::str;

pub struct Scanner<R> {
    reader: R,
    buffer: Vec<String>,
}

impl<R: io::BufRead> Scanner<R> {
    pub fn new(reader: R) -> Self {
        Self {
            reader,
            buffer: vec![],
        }
    }

    pub fn token<T: str::FromStr>(&mut self) -> T {
        loop {
            if let Some(token) = self.buffer.pop() {
                return token.parse().ok().expect("Failed parse");
            }
            let mut input = String::new();
            self.reader.read_line(&mut input).expect("Failed read");
            self.buffer = input.split_whitespace().rev().map(String::from).collect();
        }
    }

    pub fn next<T: str::FromStr>(&mut self) -> Option<T> {
        let res = self.buffer.pop();
        match res {
            Some(token) => {
                if let Ok(value) = token.parse() {
                    return Some(value);
                }
                self.buffer.push(token);
            }
            None => {
                let mut input = String::new();
                self.reader.read_line(&mut input).expect("Failed read");
                self.buffer = input.split_whitespace().rev().map(String::from).collect();
            }
        }
        None
    }
}

#[allow(dead_code)]
#[allow(non_snake_case)]
fn main() {
    let mut handle = io::stdin().lock();
    let mut buf = String::new();
    handle.read_line(&mut buf).unwrap();
    let T = buf.trim().parse::<usize>().unwrap();
    for _ in 0..T {
        let mut cur = 1923 as usize;
        loop {
            println!("? {cur}");
            buf.clear();
            handle.read_line(&mut buf).unwrap();
            let ans = buf.trim().parse::<i64>().unwrap();
            if ans != 0 {
                break;
            }
            cur += 1;
        }
        println!("! {cur}");
    }
}