//#pragma GCC optimize("Ofast", "unroll-loops")
//#pragma GCC target("sse", "sse2", "sse3", "ssse3", "sse4")
#ifdef LOCAL
#include <iostream>
#include <cmath>
#include <algorithm>
#include <stdio.h>
#include <cstdint>
#include <cstring>
#include <string>
#include <cstdlib>
#include <vector>
#include <bitset>
#include <map>
#include <queue>
#include <ctime>
#include <stack>
#include <set>
#include <list>
#include <random>
#include <deque>
#include <functional>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <complex>
#include <numeric>
#include <cassert>
#include <array>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <thread>
#else
#include <bits/stdc++.h>
#endif

#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define mp make_pair
#define pb push_back
#define fir first
#define sec second
#define fi first
#define se second

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;

template<typename T>
inline bool umin(T &a, T b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<typename T>
inline bool umax(T &a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

#ifdef LOCAL
#define D for (bool _FLAG = true; _FLAG; _FLAG = false)
#define LOG(...) print(#__VA_ARGS__" ::", __VA_ARGS__) << endl
template <class ...Ts> auto &print(Ts ...ts) { return ((cerr << ts << " "), ...); }
#else
#define D while (false)
#define LOG(...)
#endif // LOCAL

const int max_n = -1, inf = 1000111222;

mt19937 rng(228);
template<typename T = int>
inline T randll(T l = INT_MIN, T r = INT_MAX) {
    return uniform_int_distribution<T>(l, r)(rng);
}

inline ld randld(ld l = INT_MIN, ld r = INT_MAX) {
    return uniform_real_distribution<ld>(l, r)(rng);
}

int MX = 0;

map <set <string>, string> to_ask;

inline int rec (vector <string> have, int d = 1, bool gg = true) {
    if (have.empty()) {
        return d - 1;
    }
//    LOG(d);
    umax(MX, d);
    int mx = inf;
    vector <int> can;
//    shuffle(all(have), rng);
    int y = 0;
    for (int i = 0; i < len(have); i++) {
        int cnt[9] = {};
        for (auto &j : have) {
            int cur = 0;
            for (int k = 0; k < 8; k++) {
                if (have[i][k] == j[k]) {
                    ++cur;
                }
            }
            ++cnt[cur];
        }
        int val = 0;
        for (int j = 0; j < 8; j++) {
            umax(val, cnt[j]);
        }
        if (umin(mx, val)) {
            y = 0;
            can.clear();
        }
        if (mx == val) {
            ++y;
            can.pb(i);
        }
    }
    int res = inf;
    LOG(len(can));
    int best = -1;
    for (int pos : can) {
        vector<string> nice[9];
        for (auto &j: have) {
            int cur = 0;
            for (int k = 0; k < 8; k++) {
                if (have[pos][k] == j[k]) {
                    ++cur;
                }
            }
            nice[cur].pb(j);
        }
        int cur = 0;
        for (int j = 0; j < 8; j++) {
            umax(cur, rec(nice[j], d + 1, false));
        }
        if (umin(res, cur)) {
            best = pos;
        }
    }
    if (gg) {
        int pos = best;
        vector<string> nice[9];
        for (auto &j: have) {
            int cur = 0;
            for (int k = 0; k < 8; k++) {
                if (have[pos][k] == j[k]) {
                    ++cur;
                }
            }
            nice[cur].pb(j);
        }
        for (int j = 0; j < 8; j++) {
            rec(nice[j], d + 1, true);
        }
        set <string> s(all(have));
        assert(!to_ask.count(s));
        to_ask[s] = have[pos];
    }
    return res;
}

int main() {
//    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    string s = "RQKBBNRN";
    sort(all(s));
    vector <string> can;
    do {
        bool ok = true;
        map <char, vector <int> > have;
        for (int i = 0; i < 8; i++) {
            have[s[i]].pb(i);
        }
        if ((have['B'][0] ^ have['B'][1]) % 2 == 0) {
            ok = false;
        }
        if (have['K'][0] < have['R'][0] || have['K'][0] > have['R'][1]) {
            ok = false;
        }
        if (ok) {
            can.pb(s);
        }
    } while (next_permutation(all(s)));
//    LOG(len(can));
//    LOG(rec(can));
//    LOG(MX);
    rec(can);
    string game;
    int num;
    while (cin >> game) {
        if (game == "END") {
            break;
        }
        cin >> num;
        set<string> cur(all(can));
        while (true) {
            string A = to_ask[cur];
            cout << A << endl;
            int res;
            cin >> res;
            if (res == 8) {
                break;
            }
            set <string> new_cur;
            for (auto &j : cur) {
                int cc = 0;
                for (int k = 0; k < 8; k++) {
                    if (A[k] == j[k]) {
                        ++cc;
                    }
                }
                if (cc == res) {
                    new_cur.insert(j);
                }
            }
            cur.swap(new_cur);
        }
    }
}