use std::io;
use std::io::prelude::*;

fn ask(n: String) -> bool {
    let mut stdout = io::stdout();
    stdout.write(format!("? {}\n", n).as_bytes());
    stdout.flush();
    let mut stdin = io::stdin();
    let mut input = String::new();
    stdin.read_line(&mut input);
    input.starts_with("Y")
}

fn is_last(s: &str) -> bool {
    if s.starts_with("1") || (s.len() == 0 && ask("1000000000000".to_string())) {
        let mut t = String::new();
        for _ in 0..s.len()+1 {
            t += "9";
        }
        ask(t)
    } else {
        let mut t = String::new();
        t += "1";
        for _ in 0..s.len()+1 {
            t += "0";
        }
        !ask(t)
    }
}
fn find_last(s: &str) -> i32 {
    let mut lb = if s.len() == 0 { 1 } else { 0 } - 1;
    let mut ub = 9;
    while ub - lb > 1 {
        let x = (lb + ub) / 2;
        if ask(s.to_string() + &x.to_string() + "0") {
            ub = x;
        } else {
            lb = x;
        }
    }
    ub
}
fn find_char(s: &str) -> (i32, bool) {
    let mut lb = 0;
    let mut ub = 10;
    // [lb, ub)
    while ub - lb > 1 {
        let x = (lb + ub) / 2;
        if ask(s.to_string() + &x.to_string()) {
            lb = x;
        } else {
            ub = x;
        }
    }
    if lb != 9 {
        (lb, false)
    } else if is_last(s) {
        (find_last(s), true)
    } else {
        (9, false)
    }
}
fn main() {
    let mut ans = String::new();
    loop {
        let (a, b) = find_char(&ans);
        ans += &a.to_string();
        if b {
            break;
        }
    }

    let mut stdout = io::stdout();
    stdout.write(format!("! {}\n", ans).as_bytes());
    stdout.flush();
}

// --- template ---
#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
use std::collections::HashSet;

pub trait FromLn {
    fn fromln(s: &str) -> Self;
}
pub fn readln<T: FromLn>() -> T {
    let mut buf = String::new();
    let _ = ::std::io::stdin().read_line(&mut buf).unwrap();
    T::fromln(buf.trim())
}
pub fn readlns<T: FromLn>(n: usize) -> Vec<T> {
    let mut vs = vec![];
    for _ in 0..n { vs.push(readln()); }
    vs
}
macro_rules! fromln_primitives {
    ($($t:ty),*) => { $(
        impl FromLn for $t {
            fn fromln(s: &str) -> $t {
                s.parse().unwrap()
            }
        }
    )* }
}
fromln_primitives!(String, bool, f32, f64, isize, i8, i16, i32, i64, usize, u8, u16, u32, u64);
impl<T> FromLn for Vec<T> where T: FromLn {
    fn fromln(s: &str) -> Vec<T> {
        s.split_whitespace().map(T::fromln).collect()
    }
}
impl FromLn for Vec<char> {
    fn fromln(s: &str) -> Vec<char> {
        s.chars().collect()
    }
}
macro_rules! fromln_tuple {
    ($($t:ident),*) => {
        impl<$($t),*> FromLn for ($($t),*) where $($t: FromLn),* {
            fn fromln(s: &str) -> ($($t),*) {
                let mut it = s.split_whitespace();
                let t = ($($t::fromln(it.next().unwrap())),*);
                assert_eq!(it.next(), None);
                t
            }
        }
    }
}
fromln_tuple!(A, B);
fromln_tuple!(A, B, C);
fromln_tuple!(A, B, C, D);
fromln_tuple!(A, B, C, D, E);
fromln_tuple!(A, B, C, D, E, F);

Measured memory_bytes: 4692