// #include <unistd.h>
#include <algorithm>
#include <iostream>
#include <vector>
#include <deque>
#include <list>
#include <cassert>
using namespace std;
#define LOG(x) ;//{x;  cerr.flush();}
#define FOR(i, n) for(int i = 0, __n = (n); i < __n; i++)

#include <vector>
#include <string>
#include <algorithm>
#include <cstdint>

const uint64_t xork[2] { 0xD1B54A32D192ED03ULL, 0xA3C6EF372FE94F82ULL };
string xorkey(const string& s, uint64_t key) {
  string out = s;

  for (int i = 0; i < (int)s.size(); i++) {
    bool bit = ( key >> (i % 64)) & 1;
    bool val = s[i] - '0';
    out[i] = char('0' + (bit != val));
    
  }

  return out;
}


char buff[10000];

char coded[3] = {'N', 'K', 'P'};

char code(int x) {
  return coded[x];
}

int decode(char x) {
  FOR(i,3) if (coded[i] == x) return i;
}

int comp(int a, int b) {
  if(a == b) return 0;
  if((a + 1) % 3 == b) return -1;
  return 1;
}


pair<int, int> go(int p) {
  printf("%c\n", code(p));
  fflush(stdout);
  scanf("%s", buff);
  int p2 = decode(buff[0]);
  return {p2, comp(p, p2)};
}

class Binary {
    // LSB first: bits[0] = najmłodszy bit
    deque<int8_t> bits;


public:
    Binary() {}

    Binary(const string& s){
      bits.resize(s.size());
      for(size_t i = 0; i < s.size(); ++i) {
        bits[i] = s[s.size() - 1 - i] - '0';
      }
      trim();
    }

    void mul2_add(int add) {
      bits.push_front(add);
    }

    int div2() {
      if(bits.empty()) return 0;
      char res = bits.front();
      bits.pop_front();
      return res;
    }

    void mul3_add(int add) {
      int carry = add;
      FOR(i, bits.size()) {
        int cur = carry + bits[i]*3;
        bits[i] = cur % 2;
        carry = cur / 2;
      }
      while(carry) {
        bits.push_back(carry % 2);
        carry /= 2;
      }
    }

    int div3() {
      if(bits.empty()) return 0;
      int rem = 0;

      for (int i = bits.size()-1; i >= 0; i--) {
        int cur = rem * 2 + bits[i];
        bits[i] = cur / 3;
        rem = cur % 3;
      }
      trim();
      return rem;
    }

    void trim() {
      while (!bits.empty() && bits.back() == 0) bits.pop_back();
    }

    string to_string() const {
      if(bits.empty()) return "";
      string res;
      for (size_t i = 0; i < bits.size(); ++i) {
        res.push_back(bits[bits.size() - 1 - i] + '0');
      }
      return res;
    }
    size_t size() const {
      return bits.size();
    }

    void add(const Binary& other) {
      int carry = 0;
      size_t n = max(bits.size(), other.bits.size());
      bits.resize(n, 0);
      FOR(i, n) {
        int cur = bits[i] + (i < other.bits.size() ? other.bits[i] : 0) + carry;
        bits[i] = cur % 2;
        carry = cur / 2;
      }
      if(carry) bits.push_back(carry);
    }
};


class Code {
  int n;
  Binary A;
  Binary lim;
public:
  Code(const string& s): A(s), lim("1"), n(s.size()) {
  }
  Code(int n):n(n), A(""), lim("1") {

  }

  int code3() {
    lim.mul3_add(0);
    return A.div3();
  }

  int code2() {
    lim.mul2_add(0);
    return A.div2();
  }

  void decode3(int p) {
    FOR(i, p) {
      A.add(lim);
    }
    lim.mul3_add(0);
  }

  void decode2(int p) {
    FOR(i, p) {
      A.add(lim);
    }
    lim.mul2_add(0);
  }

  int remaining() const {
    if(lim.size() >= n+1) return 0;
    else return n + 1 - lim.size();
  }
  const Binary & value() const {
    return A;
  }
  const Binary & mult() const {
    return lim;
  }
  
  string to_string() const {
    return A.to_string() + "/" + lim.to_string();
  }
};


// const int MAGIC3 = 157;
// const int MAGIC2 = 100;



int main() {
  
  scanf("%s", buff);

  int player = (buff[0]=='B');

  int n, t;
  scanf("%d%d", &n, &t);


  FOR(test, t) {
    LOG(cerr << "Player" << player << ": test" << test << endl;)
    scanf("%s", buff);

    int result = 0;

    int ap = 0, bp = 0;

    string inp(buff);
    inp = xorkey(inp,xork[player]);
    Code A = inp;
    Code B(n);
    int step = 0; int step2 = 0, step3 = 0;
    while(A.remaining() > 0 || B.remaining() > 0) {
      LOG(cerr << "P" << player << " r" << result << " = " << A.to_string() << " " << B.to_string() << endl;)
      if (result == 0) {
        int p = A.code3();
        // LOG(cerr << player << ":code3 " << p << endl;)
        if (player) p = (p + step3%3)%3;
        auto [p2, res] = go(p);
        if (!player) p2 = (p2 + 3 - step3%3)%3;
        result += res;
        B.decode3(p2);
        step3++;
      } else {
        
        if((A.remaining() < B.remaining()) || (player == 0 && A.remaining() == B.remaining() )) {
          // LOG(cerr << player << ":code2 me " << endl;)
          auto [p2, res] = result > 0 ? go(0) : go(1);
          // jeśli wynik jest dodatni, to chcemy przegrać, więc wysyłamy 0, jeśli ujemny, to chcemy wygrać, więc wysyłamy 1

          result += res;
          if(step2 & 1) p2 = 1 - p2; // optimizer
          B.decode2(p2);
        } else {
          int p = A.code2();
          if(step2 & 1) p = 1 - p; // optimizer
          // LOG(cerr << player <<":code2 you " << p << endl;)
          auto [p2, res] = go(p);
          result += res;
        }
        step2++;
      }
      // LOG(if(player== 0) {
      //   cerr << "[" << player << "] " << result << A.remaining() << " " << B.remaining() << " " << A.to_string() << "<>" << B.to_string() << endl;
       
      // })

      step ++;
    }
    LOG(cerr << "P" << player << " r" << result << " = " << A.to_string() << " " << B.to_string() << endl;)

    string sB = B.value().to_string();
    sB = string(n - sB.size(), '0') + sB;
    sB = xorkey(sB, xork[!player]);
    
    printf("! %s\n", sB.c_str());
    fflush(stdout);
    // cerr<< "! " << step << " " << step2 << " " << step3 << " " << step2 + step3*1.58 << endl;
    // cerr.flush();
    //  usleep(20000);
    cerr << step << endl; cerr.flush();
  }


  return 0;
}