// includes {{{
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<tuple>
#include<cmath>
#include<random>
#include<cassert>
#include<bitset>
#include<cstdlib>
// #include<deque>
// #include<multiset>
// #include<cstring>
// #include<bits/stdc++.h>
// }}}
using namespace std;
using ll = long long;

// #undef DEBUG
// #define DEBUG
// DEBUG {{{
#include <array>
#include <deque>
#include <iostream>
#include <list>
#include <queue>
#include <stack>
#include <tuple>
#include <valarray>
#include <vector>
template < int n, class... T >
typename std::enable_if< (n >= sizeof...(T)) >::type __output_tuple(
    std::ostream &, std::tuple< T... > const &) {}
template < int n, class... T >
typename std::enable_if< (n < sizeof...(T)) >::type __output_tuple(
    std::ostream &os, std::tuple< T... > const &t) {
  os << (n == 0 ? "" : ", ") << std::get< n >(t);
  __output_tuple< n + 1 >(os, t);
}
template < class... T >
std::ostream &operator<<(std::ostream &os, std::tuple< T... > const &t) {
  os << "(";
  __output_tuple< 0 >(os, t);
  os << ")";
  return os;
}
template < class T, class U >
std::ostream &operator<<(std::ostream &os, std::pair< T, U > const &p) {
  os << "(" << p.first << ", " << p.second << ")";
  return os;
}
template < class T >
std::ostream &operator<<(std::ostream &os, const std::stack< T > &a) {
  os << "{";
  for(auto tmp = a; tmp.size(); tmp.pop())
    os << (a.size() == tmp.size() ? "" : ", ") << tmp.top();
  os << "}";
  return os;
}
template < class T, class Container, class Compare >
std::ostream &operator<<(std::ostream &os,
    std::priority_queue< T, Container, Compare > a) {
  os << "{ (top) ";
  while(a.size()) os << a.top() << (a.size() == 1 ? "" : ", "), a.pop();
  os << " }";
  return os;
}
template < class T, class Container >
std::ostream &operator<<(std::ostream &os, std::queue< T, Container > a) {
  os << "{ ";
  while(a.size()) os << a.front() << (a.size() == 1 ? "" : ", "), a.pop();
  os << " }";
  return os;
}
#ifdef DEBUG
#if !defined(DEBUG_OUT)
#define DEBUG_OUT std::cerr
#endif
#define dump(...)                                                                \
  [&]() {                                                                        \
    auto __debug_tap = std::make_tuple(__VA_ARGS__);                             \
    DEBUG_OUT << "[" << __LINE__ << "] " << #__VA_ARGS__ << " = " << __debug_tap \
    << std::endl;                                                      \
  }()
template < class T >
inline void dump2D(T &d, size_t sizey, size_t sizex) {
  for(size_t i = 0; i < sizey; i++) {
    DEBUG_OUT << "\t";
    for(size_t j = 0; j < sizex; j++)
      DEBUG_OUT << d[i][j] << (j + 1 == sizex ? "" : "\t");
    DEBUG_OUT << std::endl;
  }
}
template < class T >
inline void dump1D(T &d, size_t sizey) {
  for(size_t i = 0; i < sizey; i++) {
    DEBUG_OUT << d[i] << (i + 1 == sizey ? "" : " ");
  }
  DEBUG_OUT << std::endl;
}
template <
class T, class = typename std::iterator_traits< decltype(begin(T())) >::value_type,
      class = typename std::enable_if< !std::is_same< T, std::string >::value >::type >
      std::ostream &operator<<(std::ostream &os, const T &a) {
        os << "{";
        for(auto ite = begin(a); ite != end(a); ++ite)
          os << (ite == begin(a) ? "" : ", ") << *ite;
        os << "}";
        return os;
      }
#else
#define dump(...) ((void) 42)
#define dump2D(...) ((void) 42)
#define dump1D(...) ((void) 42)
template <
class T, class = typename std::iterator_traits< decltype(begin(T())) >::value_type,
      class = typename std::enable_if< !std::is_same< T, std::string >::value >::type >
      std::ostream &operator<<(std::ostream &os, const T &a) {
        for(auto ite = begin(a); ite != end(a); ++ite)
          os << (ite == begin(a) ? "" : " ") << *ite;
        return os;
      }
#endif
// }}}


string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

string local_s;

int ask(string t) {
  assert(1 <= t.size() && t.size() <= 128);
  cout << "? " << t << endl;

  int x;
#ifdef DEBUG
  if(local_s.size() == 0) {
    local_s = "";
    random_device rnd;
    mt19937 mt(rnd());
    uniform_int_distribution<ll> rd(0, chars.size() - 1);
    uniform_int_distribution<ll> rd2(1, 128);
    int glen = rd2(mt);
    glen = 128;
    for(int i = 0; i < glen; i++) {
      local_s += chars[rd(mt)];
    }
    // local_s = chars + chars + "0011";
    local_s = "Atcod3rIsGreat";
    dump(local_s);
    dump(local_s.size(), glen);
  }
  x = 0;
  for(int i = 0; i < max(local_s.size(), t.size()); i++) {
    if(i >= local_s.size()) {
      x++;
    } else if(i >= t.size()) {
      x++;
    } else {
      if(local_s[i] != t[i]) x++;
    }
  }
  return x;
#endif

  cin >> x;
  return x;
}

int ans(string t) {
  assert(1 <= t.size() && t.size() <= 128);
  cout << "! " << t << endl;

#ifdef DEBUG
  cout << (local_s == t ? "AC" : "WA") << endl;
#endif

  exit(0);
  return -1;
}

map<char, int> cnt;
int cnext(int f) {
  for(int x = f; x < chars.size(); x++) {
    dump(chars[x]);
    assert(cnt[chars[x]] >= 0);
    if(cnt[chars[x]] > 0) return x;
  }
  assert(!"cnext");
}

char base_c = 0;
int base;
int known[128];
string ans_s;

int len = 0;
void sol(char c) {
  assert(cnt[c] > 0);
  dump("sol", c, cnt[c]);
  while(cnt[c] > 0) {
    int unkonwn_total = 0;
    for(int i = 0; i < len; i++) {
      unkonwn_total += !known[i];
    }
    int ok = unkonwn_total;
    int ng = 0;
    while(ok - ng > 1) {
      int mid = (ok + ng) / 2;
      int done = 0;
      string t(len, base_c);
      for(int i = 0; i < len; i++) {
        if(!known[i]) {
          if(done < mid) {
            done++;
            t[i] = c;
          }
        } else {
          t[i] = ans_s[i];
        }
      }
      int diff = ask(t) - base;
      dump(diff);
      assert(diff <= 0);
      if(diff <= -1) ok = mid; else ng = mid;
    }

    int ok_i = -1;
    int un_c = 0;
    for(int i = 0; i < len; i++) {
      if(!known[i]) {
        un_c++;
        if(un_c == ok) {
          ok_i = i;
          break;
        }
      }
    }
    assert(ok_i >= 0 && ok_i < len);
    dump(ok_i);
    known[ok_i] = 1;
    ans_s[ok_i] = c;
    base--;
    cnt[c]--;
  }
}

int main() {
  sort(chars.begin(), chars.end());
  chars.erase(unique(chars.begin(), chars.end()), chars.end());
  assert(chars.size() == 26 + 26 + 10);
  // 62times ; 788 times left
  for(auto c: chars) {
    cnt[c] = 128 - ask(string(128, c));
    len += cnt[c];
  }

  int c1 = cnext(0);
  int c1c = cnt[chars[c1]];
  assert(c1c > 0);
  if(c1c == len) {
    ans(string(len, chars[c1]));
  }

  dump(len, c1);

  int c2 = cnext(c1+1);
  int c2c = cnt[chars[c2]];
  assert(c2c > 0);

  dump(c2);

  char zeroc = 0;
  for(auto c: chars) {
    if(cnt[c] == 0) zeroc = c;
  }

  if(zeroc == 0) {
    char t1 = 0, t2 = 0;
    for(auto c: chars) {
      if(t2 == 0 || cnt[t2] > cnt[c]) t2 = t1, t1 = c;
      if(t1 != 0 && t2 != 0 && cnt[t1] > cnt[t2]) swap(t1, t2);
    }

    assert(t1 != 0 && t2 != 0);
    assert(cnt[t1] < 3 && cnt[t2] < 3);

    c1c = cnt[t1];
    c2c = cnt[t2];

    string t = string(len, t1);
    random_device rnd;
    mt19937 mt(rnd());
    uniform_int_distribution<ll> rd(0, ll(-1));
    int last = 0;
    int base0 = len;

    int Z = c1c + c2c;
    while(last != -Z) {
      for(int i = 0; i < len; i++) {
        t[i]=(rd(mt)%2==0)?t1:t2;
      }
      last = ask(t) - base0;
      dump(last);
      if(last == Z) {
        last = -Z;
        swap(t1, t2);
        for(auto&e:t) if(e == t1) e = t2; else e = t1;
      }
    }

    for(int i = 0; i < len; i++) if(t[i] == t1) known[i] = 1;
    base_c = t1;
    base = len - c1c;
    ans_s = string(len, t1);
    dump(ask(string(len, t1)), len);

    sol(t2);

    for(int i = 0; i < len; i++) if(t[i] == t1) known[i] = 0;

    base_c = t2;
    base += c2c;
    dump("no zeroc");
  } else {
    dump("zeroc", zeroc);
    base_c = zeroc;
    base = len;
    ans_s = string(len, zeroc);
  }

  for(char c: chars) {
    if(cnt[c] > 0) {
      sol(c);
    }
  }

  assert(base == 0);

  ans(ans_s);
  return 0;
}


Measured memory_bytes: 3804