use std::io::{self, Read, Write};

#[derive(Clone, Copy)]
struct Edge {
    to: usize,
    weight: u32,
}

fn get_next_byte() -> Option<u8> {
    let mut buf = [0; 1];
    match io::stdin().read(&mut buf) {
        Ok(1) => Some(buf[0]),
        _ => None,
    }
}

fn read_string() -> String {
    let mut s = String::new();
    let mut started = false;
    while let Some(b) = get_next_byte() {
        if b.is_ascii_whitespace() {
            if started { break; }
        } else {
            started = true;
            s.push(b as char);
        }
    }
    s
}

fn read_usize() -> usize {
    let mut res = 0;
    let mut started = false;
    while let Some(b) = get_next_byte() {
        if b.is_ascii_whitespace() {
            if started { break; }
        } else {
            started = true;
            res = res * 10 + (b - b'0') as usize;
        }
    }
    res
}

fn read_bit() -> u8 {
    loop {
        if let Some(b) = get_next_byte() {
            if b == b'0' { return 0; }
            if b == b'1' { return 1; }
        } else {
            std::process::exit(0);
        }
    }
}

fn send_bit(b: u32) {
    println!("+ {}", b);
    io::stdout().flush().unwrap();
}

fn ask_bit() -> u32 {
    println!("?");
    io::stdout().flush().unwrap();
    read_bit() as u32
}

fn main() {
    let who = read_string();
    let is_algosia = who == "Algosia";
    let n = read_usize();
    let m = read_usize();

    let mut adj = vec![vec![]; n + 1];
    for _ in 0..m {
        let u = read_usize();
        let v = read_usize();
        let w = read_usize() as u32;
        adj[u].push(Edge { to: v, weight: w });
        adj[v].push(Edge { to: u, weight: w });
    }

    let mut dist = vec![u32::MAX; n + 1];
    let mut my_dist = vec![u32::MAX; n + 1];
    let mut settled = vec![false; n + 1];

    dist[1] = 0;
    settled[1] = true;
    let mut settled_count = 1;
    let mut current_dist = 0;

    let mut relax = |u: usize, d: u32, adj: &[Vec<Edge>], my_dist: &mut Vec<u32>, settled: &[bool]| {
        for edge in &adj[u] {
            if !settled[edge.to] {
                if d + edge.weight < my_dist[edge.to] {
                    my_dist[edge.to] = d + edge.weight;
                }
            }
        }
    };

    relax(1, current_dist, &adj, &mut my_dist, &settled);

    let bits_for_u = if n == 1 { 0 } else { 32 - (n as u32 - 1).leading_zeros() };

    while settled_count < n {
        let mut min_d = u32::MAX;
        let mut my_u = 0;
        for i in 1..=n {
            if !settled[i] && my_dist[i] < min_d {
                min_d = my_dist[i];
                my_u = i;
            }
        }

        let my_delta: u32 = if min_d == u32::MAX {
            501
        } else {
            if min_d < current_dist {
                0
            } else {
                let d = min_d - current_dist;
                if d > 500 { 501 } else { d }
            }
        };

        let mut diff_k = -1;
        let mut i_am_winner = false;
        let mut winner_delta = 0;

        for k in 0..9 {
            let my_bit = (my_delta >> (8 - k)) & 1;
            send_bit(my_bit);
            let other_bit = ask_bit();

            if my_bit != other_bit {
                diff_k = k as i32;
                i_am_winner = my_bit == 0;
                break;
            }
        }

        if diff_k != -1 {
            if i_am_winner {
                for i in (diff_k + 1)..9 {
                    let b = (my_delta >> (8 - i)) & 1;
                    send_bit(b);
                }
                let encoded_u = my_u as u32 - 1;
                for i in 0..bits_for_u {
                    let b = (encoded_u >> (bits_for_u - 1 - i)) & 1;
                    send_bit(b);
                }
            } else {
                for i in 0..diff_k {
                    let b = (my_delta >> (8 - i)) & 1;
                    winner_delta = (winner_delta << 1) | b;
                }
                winner_delta = (winner_delta << 1) | 0;

                for _ in (diff_k + 1)..9 {
                    let b = ask_bit();
                    winner_delta = (winner_delta << 1) | b;
                }

                let mut decoded_u = 0;
                for _ in 0..bits_for_u {
                    let b = ask_bit();
                    decoded_u = (decoded_u << 1) | b;
                }
                my_u = (decoded_u + 1) as usize;
            }
        } else {
            if my_delta == 501 {
                break;
            }
            i_am_winner = is_algosia;
            winner_delta = my_delta;

            if i_am_winner {
                let encoded_u = my_u as u32 - 1;
                for i in 0..bits_for_u {
                    let b = (encoded_u >> (bits_for_u - 1 - i)) & 1;
                    send_bit(b);
                }
            } else {
                let mut decoded_u = 0;
                for _ in 0..bits_for_u {
                    let b = ask_bit();
                    decoded_u = (decoded_u << 1) | b;
                }
                my_u = (decoded_u + 1) as usize;
            }
        }

        let actual_delta = if diff_k != -1 {
            if i_am_winner { my_delta } else { winner_delta }
        } else {
            my_delta
        };

        current_dist += actual_delta;
        let u = my_u;

        if !settled[u] {
            settled[u] = true;
            dist[u] = current_dist;
            settled_count += 1;

            relax(u, current_dist, &adj, &mut my_dist, &settled);
        }
    }

    if is_algosia {
        print!("! {}", dist[1]);
        for i in 2..=n {
            print!(" {}", dist[i]);
        }
        println!();
        io::stdout().flush().unwrap();
    }
}