#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define LOCAL
#ifdef LOCAL
#include "../debug/debug.h"
#else
#define debug(...)
#define debugArr(...)
#endif

using namespace std;
using namespace __gnu_pbds;

using ll = long long;
using db = long double;
using pi = pair<int,int>;
using pl = pair<ll,ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vb = vector<bool>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vvi = vector<vi>;

#define mp make_pair
#define eb emplace_back
#define pb push_back
#define x first
#define y second
#define sz(x) int((x).size())
#define bg(x) begin(x)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(), (x).rend() 
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define per(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define ft front()
#define bk back()
#define rsz resize
#define ins insert
#define each(a,x) for(auto&a:x)

template<class T> bool ckmin(T& a, T b) { return b<a?a=b,1:0; }
template<class T> bool ckmax(T& a, T b) { return b>a?a=b,1:0; }
template<class T> int lwb(vector<T>& a, const T& b) { return int(lower_bound(all(a),b)-bg(a)); }
template<class T> int upb(vector<T>& a, const T& b) { return int(upper_bound(all(a),b)-bg(a)); }
template<class T> void remdup(vector<T>& v) { sort(all(v)); v.erase(unique(all(v)),end(v)); }

template<int MOD, int RT> struct mint {
    static const int mod = MOD;
    static constexpr mint rt() { return RT; }
    int v; explicit operator int() const { return v; }
    mint() : v(0) {}
    mint(ll _v) { v = int((-MOD < _v && _v < MOD) ? _v : _v % MOD);
        if (v < 0) v += MOD; }
    bool operator==(const mint& o) const {
        return v == o.v; }
    friend bool operator!=(const mint& a, const mint& b) { 
        return !(a == b); }
    friend bool operator<(const mint& a, const mint& b) { 
        return a.v < b.v; }

    mint& operator+=(const mint& o) { 
        if ((v += o.v) >= MOD) v -= MOD; 
        return *this; }
    mint& operator-=(const mint& o) { 
        if ((v -= o.v) < 0) v += MOD; 
        return *this; }
    mint& operator*=(const mint& o) { 
        v = int((ll)v*o.v%MOD); return *this; }
    mint& operator/=(const mint& o) { return (*this) *= inv(o); }
    friend mint pow(mint a, ll p) {
        mint ans = 1; assert(p >= 0);
        for (; p; p /= 2, a *= a) if (p&1) ans *= a;
        return ans; }
    friend mint inv(const mint& a) { assert(a.v != 0); 
        return pow(a,MOD-2); }
        
    mint operator-() const { return mint(-v); }
    mint& operator++() { return *this += 1; }
    mint& operator--() { return *this -= 1; }
    friend mint operator+(mint a, const mint& b) { return a += b; }
    friend mint operator-(mint a, const mint& b) { return a -= b; }
    friend mint operator*(mint a, const mint& b) { return a *= b; }
    friend mint operator/(mint a, const mint& b) { return a /= b; }
    friend ostream& operator<<(ostream& o, const mint& a) { return o << a.v; }
    friend istream& operator>>(istream& i, mint& a) {
        ll x; i >> x; a = x;
        return i; }
};

const int MOD = 998244353;
using mi = mint<MOD,5>;
using vmi = vector<mi>;
using pmi = pair<mi,mi>;
using vpmi = vector<pmi>;

const pi MOVES[] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};

#ifdef LOCAL
mt19937_64 rng(0xabadbeef);
#else
mt19937_64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
#endif

ll randr(ll l, ll r) { return uniform_int_distribution<ll>(l, r)(rng); }

const int N = 2048;
const int INF = 1e9;
int d[N];
bool done[N];
vpi g[N];
int n, m;
string me;

int recv(int k) {
    int x = 0;
    rep(i,0,k) {
        cout << "?" << endl;
        cout.flush();
        int dig;
        cin >> dig;
        x = x*2+dig;
    }
    return x;
}

void send(int x, int k) {
    per(i,0,k) {
        int dig = (x >> i) & 1;
        cout << "+ " << dig << endl;
        cout.flush();
    }
}

int recv_v() { return recv(11); }
int recv_c() { return recv(9); }

void send_v(int x) { send(x, 11); }
void send_c(int x) { send(x, 9); }

void run() {
    int prv_dist = 0;
    priority_queue<pi, vpi, greater<pi>> pq;
    d[0]=0;
    rep(i,1,n) pq.emplace(INF, i);
    pq.emplace(0, 0);
    while (!pq.empty()) {
        auto [dist, v] = pq.top();
        if (done[v]) {
            pq.pop();
            continue;
        }
        int delta = dist - prv_dist;
        ckmin(delta, 501);
        int other_delta;
        if (me == "Algosia") {
            send_c(delta);
            other_delta = recv_c();
        }
        else {
            other_delta = recv_c();
            send_c(delta);
        }
        if (delta < other_delta || (delta == other_delta && me == "Algosia")) {
            send_v(v);
        }
        else {
            delta = other_delta;
            v = recv_v();
        }

        assert(delta <= 500);

        done[v] = 1;
        d[v] = prv_dist + delta;
        prv_dist = d[v];

        for (auto [dd, u] : g[v]) {
            if (ckmin(d[u], d[v] + dd)) {
                pq.emplace(d[u], u);
            }
        }
    }
    if (me == "Algosia") {
        cout << "! ";
        rep(i,0,n) {
            cout << d[i] << ' ';
        }
        cout.flush();
    }
}

signed main() {
    cin.tie(0)->sync_with_stdio(0);

    cin >> me >> n >> m;

    rep(i,0,m) {
        int a, b, c;
        cin >> a >> b >> c;
        a--; b--;
        g[a].eb(c, b);
        g[b].eb(c, a);
    }

    rep(i,0,N) d[i]=INF;

    run();


    return 0;
}