#if __INCLUDE_LEVEL__ == 0

#include <bits/stdc++.h>

using namespace std;

#include __BASE_FILE__

namespace {

using S = array<char, 8>;

int get_pos(const S& s, int k) {
  for (int i : rep(8)) {
    if (s[i] == 0 && k-- == 0) {
      return i;
    }
  }
  assert(false);
}

vector<S> v;

void init() {
  for (int b0 : {0, 2, 4, 6}) {
    for (int b1 : {1, 3, 5, 7}) {
      for (int ri : rep(6)) {
        for (int ki : rep(ri)) {
          for (int li : rep(ki)) {
            for (int qi : rep(3)) {
              S s{};
              s[b0] = 'B';
              s[b1] = 'B';
              s[get_pos(s, ri)] = 'R';
              s[get_pos(s, ki)] = 'K';
              s[get_pos(s, li)] = 'R';
              s[get_pos(s, qi)] = 'Q';
              for (int i : rep(8)) {
                if (s[i] == 0) {
                  s[i] = 'N';
                }
              }
              v.push_back(s);
            }
          }
        }
      }
    }
  }
}

int get_n_correct(int i, int j) {
  int ret = 0;
  for (int k : rep(8)) {
    ret += v[i][k] == v[j][k];
  }
  return ret;
}

void solve() {
  init();
  while (true) {
    string s;
    cin >> s;
    if (s == "END") {
      break;
    }
    int game_id;
    cin >> game_id;
    bitset<960> bs;
    bs.set();
    while (true) {
      int best = -1;
      int mn = 1e9;
      for (int cand : rep(960)) {
        array<int, 9> occ{};
        for (int i : bs) {
          ++occ[get_n_correct(i, cand)];
        }
        if (chmin(mn, ranges::max(occ))) {
          best = cand;
        }
      }
      print(ALL(string, v[best]));
      int n_correct;
      cin >> n_correct;
      if (n_correct == 8) {
        break;
      }
      for (int i : bs) {
        if (get_n_correct(best, i) != n_correct) {
          bs[i] = 0;
        }
      }
      if (bs.count() == 1) {
        print(ALL(string, v[bs._Find_first()]));
        cin >> n_correct;
        assert(n_correct == 8);
        break;
      }
    }
  }
}

}  // namespace

int main() {
  ios::sync_with_stdio(false);

  solve();
}

#else  // __INCLUDE_LEVEL__

#undef assert
#define assert(expr) (expr) || (__builtin_unreachable(), 0)

#define ALL(f, r, ...) \
  [&](auto&& _) { return f(begin(_), end(_), ##__VA_ARGS__); }(r)

namespace std {

template <size_t N>
auto begin(const bitset<N>& x) {
  struct {
    const bitset<N>* p;
    size_t i;

    bool operator!=(int) const { return i < p->size(); }
    void operator++() { i = p->_Find_next(i); }
    size_t operator*() const { return i; }
  } ret{&x, x._Find_first()};
  return ret;
}

template <size_t N>
int end(const bitset<N>&) {
  return 0;
}

}  // namespace std

template <class T, class U = T>
bool chmin(T& x, U&& y) {
  return y < x && (x = forward<U>(y), true);
}

template <class T, class U = T>
bool chmax(T& x, U&& y) {
  return x < y && (x = forward<U>(y), true);
}

namespace std {

template <class T1, class T2>
istream& operator>>(istream& is, pair<T1, T2>& p) {
  return is >> p.first >> p.second;
}

template <class... Ts>
istream& operator>>(istream& is, tuple<Ts...>& t) {
  return apply([&is](auto&... xs) -> istream& { return (is >> ... >> xs); }, t);
}

template <class... Ts>
istream& operator>>(istream& is, tuple<Ts&...>&& t) {
  return is >> t;
}

template <class R, enable_if_t<!is_convertible_v<R, string>>* = nullptr>
auto operator>>(istream& is, R&& r) -> decltype(is >> *begin(r)) {
  for (auto&& e : r) {
    is >> e;
  }
  return is;
}

template <class T1, class T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
  return os << p.first << ' ' << p.second;
}

template <class... Ts>
ostream& operator<<(ostream& os, const tuple<Ts...>& t) {
  auto f = [&os](const auto&... xs) -> ostream& {
    [[maybe_unused]] auto sep = "";
    ((os << exchange(sep, " ") << xs), ...);
    return os;
  };
  return apply(f, t);
}

template <class R, enable_if_t<!is_convertible_v<R, string_view>>* = nullptr>
auto operator<<(ostream& os, R&& r) -> decltype(os << *begin(r)) {
  auto sep = "";
  for (auto&& e : r) {
    os << exchange(sep, " ") << e;
  }
  return os;
}

}  // namespace std

template <class... Ts>
void print(Ts&&... xs) {
  cout << tie(xs...) << '\n';
}

inline auto rep(int l, int r) { return views::iota(min(l, r), r); }
inline auto rep(int n) { return rep(0, n); }
inline auto rep1(int l, int r) { return rep(l, r + 1); }
inline auto rep1(int n) { return rep(1, n + 1); }
inline auto per(int l, int r) { return rep(l, r) | views::reverse; }
inline auto per(int n) { return per(0, n); }
inline auto per1(int l, int r) { return per(l, r + 1); }
inline auto per1(int n) { return per(1, n + 1); }

#endif  // __INCLUDE_LEVEL__