#include <bits/stdc++.h>

#define fi first
#define se second
#define pb push_back

typedef long long ll;
//#define int ll

using namespace std;

vector<string> pos =
{
"RNBKRQNB",
"QNRKNRBB",
"QNRKRNBB",
"NRNKBBQR",
"QBNRBNKR",
"RNKBRQBN",
"BBRQNNKR",
"QRBKNRNB",
"BNRKNRQB",
"BRQNKNRB",
"RNKBBNQR",
"RQKRBNNB",
"RBBKNNRQ",
"QRBBKNRN",
"QRBNKBRN",
"QBRKBNRN",
"RKBNQRNB",
"BRKRNNQB",
"RNBBKNQR",
"RQNBBNKR",
"BBNRKNRQ",
"RKBQNRNB",
"BQNRKBNR",
"RBQKNRBN",
"NRBKRBNQ",
"QRNBBKNR",
"NRKBRNBQ",
"RQKNRNBB",
"RNKBNQBR",
"RKBBNRQN",
"BRKRQNNB",
"BNRKRBQN",
"RKRNBNQB",
"RBBNNKRQ",
"RNQBBKNR",
"QRBKNBRN",
"RKRBNQBN",
"RQKBBRNN",
"BBRKNNRQ",
"BRNNKBRQ",
"RBQKBRNN",
"NRKBQNBR",
"RNKRNQBB",
"RKNQRBBN",
"NNRKBRQB",
"RKBBNNQR",
"RNKQBNRB",
"NQRKBNRB",
"BBQRNKRN",
"NNQBRKBR",
"RBQNNKBR",
"RKQNNRBB",
"RNQBNKBR",
"NQRKRNBB",
"BNQRKBRN",
"BRKNQBRN",
"BNRKQBNR",
"NRBKNBRQ",
"RBQKRNBN",
"BRKQRNNB",
"NBBNRQKR",
"NNBRKBRQ",
"RKNQBBNR",
"RBBQKRNN",
"QNRKBNRB",
"BQNRKNRB",
"BRNBKNRQ",
"RBNNBQKR",
"NBRNKQBR",
"RBKNQNBR",
"RNBKNQRB",
"BBNRKQRN",
"RQBBKNRN",
"RQNKBBNR",
"BNRKQRNB",
"RQBNKNRB",
"BBRQNKNR",
"RBQKBNNR",
"RBBKRNNQ",
"QBBNNRKR",
"BBQRKNNR",
"BQRBNNKR",
"QNRKRBBN",
"BBRKNQRN",
"RQNBBKRN",
"QRNBNKBR",
"NRBQKBRN",
"QBBRKRNN",
"QRNBKNBR",
"RBNNQKBR",
"NRKQBNRB",
"BBRQKNRN",
"RNQKNRBB",
"NBBRNKRQ",
"NBBRKNRQ",
"BNQBNRKR",
"NRKNQRBB",
"BRQNNBKR",
"BRNKQBNR",
"NBRQKRBN",
"NBRKBRQN",
"RBKRNQBN",
"RKNQNBBR",
"BBNRNKQR",
"NRKNBRQB",
"NNRKQRBB",
"BRQKRBNN",
"NBBRKRQN",
"RBNQBKRN",
"NRKRNBBQ",
"NQRBNKBR",
"RQBKNRNB",
"RBKNBRQN",
"BRKBQNNR",
"RBKNRQBN",
"RNKQBBNR",
"RNNBBQKR",
"RBKRBNQN",
"RQKBBNRN",
"NRKQBBNR",
"RNBBKRQN",
"BRQBKNNR",
"NRNBKQBR",
"BQNNRBKR",
"BRKBNRNQ",
"RNKNQRBB",
"BBNRNQKR",
"RQKRBBNN",
"BRKQNBRN",
"RKRBNNBQ",
"BQNNRKRB",
"BRKQNNRB",
"RKQNRBBN",
"RQKRNBBN",
"BRNBKRQN",
"NBBRKRNQ",
"BBNRKRNQ",
"RQBKNBNR",
"QRNKRNBB",
"RKNBRNBQ",
"RBBKNNQR",
"NBQRBKRN",
"RKQBBRNN",
"NBRKNQBR",
"NBRNBQKR",
"NRNKBBRQ",
"BRNKRQNB",
"BBNQRKNR",
"RKBBQNRN",
"BNNBRKRQ",
"BNRBQNKR",
"RKRNBBNQ",
"BNNRKRQB",
"BNQBRKNR",
"QNRBBNKR",
"NBRKBQNR",
"BBNRQKRN",
"RBKQNNBR",
"QNRBKRBN",
"NRKRBNQB",
"RNKBBQRN",
"RNBKRBQN",
"BNRBNKQR",
"RKBRNBNQ",
"QBNNBRKR",
"NNQBBRKR",
"RBBNKNRQ",
"BRNQKBRN",
"RBQNBKNR",
"RNQKBBRN",
"RBQNKRBN",
"BQRKRNNB",
"RNBBKNRQ",
"NRBBKNRQ",
"NQRKNRBB",
"RQKNBRNB",
"NBRKNRBQ",
"NBBNRKQR",
"NRBKQRNB",
"NRBKQNRB",
"RKNBBQRN",
"NQRBBNKR",
"BNNBRQKR",
"NNBRKRQB",
"RBKQBRNN",
"BNRKNQRB",
"RQKBNNBR",
"QRBKRNNB",
"BQRNKBRN",
"BQRBKNRN",
"RQKNRBBN",
"NBRNBKRQ",
"NRQBKRBN",
"NBBRQKRN",
"QRNNKBBR",
"RBKQBNNR",
"RKRNNBBQ",
"RKRNQNBB",
"BNNRKBQR",
"RBNKQRBN",
"RBNKBQNR",
"BRQKRNNB",
"RBNQBNKR",
"RQKNNRBB",
"BNRQKBRN",
"RQNBKRBN",
"NBBRKQRN",
"QRKBBRNN",
"RNBNKBRQ",
"BNNBQRKR",
"BNRQKRNB",
"RNBKNBRQ",
"RNNQBKRB",
"NRBBKNQR",
"BBNNRQKR",
"RKBBNQNR",
"BNRNQKRB",
"BNNQRBKR",
"RQNKBNRB",
"QRBNNKRB",
"RNKQRBBN",
"QRKNBNRB",
"RNNBQKBR",
"RBBKQRNN",
"BRNBQKRN",
"RNQKBBNR",
"QRNBBKRN",
"BNRBNQKR",
"QRNKNRBB",
"BRNKNBQR",
"RQNNKBBR",
"NRBNKQRB",
"RKBRQBNN",
"NRQKBBRN",
"BRQBNNKR",
"NRQNKRBB",
"NRNKRQBB",
"NBQRBKNR",
"QNBBRKNR",
"RNBNKRQB",
"BBQNRNKR",
"NBRKBNQR",
"RKRBBQNN",
"NRKBNRBQ",
"BBQRNNKR",
"RNNBBKRQ",
"RKNNQBBR",
"NQNRKRBB",
"NBNRBQKR",
"NBRKBNRQ",
"BBNRNKRQ",
"BQNBRKRN",
"RKNNRBBQ",
"RNNKQRBB",
"RQBKRBNN",
"BNNRKBRQ",
"RKNRBBNQ",
"RKBBNQRN",
"RBNQKRBN",
"RKQRNNBB",
"RKBBQRNN",
"BRNBQKNR",
"RNQBBNKR",
"RKNQNRBB",
"RNNBBKQR",
"NNQRBKRB",
"RBBQKNNR",
"BRKNNQRB",
"BNRKQBRN",
"BNNRKQRB",
"BRNNQKRB",
"NQRBBKRN",
"BBRQKRNN",
"RKNRNBBQ",
"RKBNQNRB",
"RKRNBQNB",
"NQRBBKNR",
"BRQBNKRN",
"BRNBQNKR",
"NRKNQBBR",
"NQRBKNBR",
"NRBKQBNR",
"BRKNQRNB",
"NQRBKRBN",
"RQNNKRBB",
"RBBKNRQN",
"QRBKNNRB",
"NRKBBRNQ",
"NQBNRKRB",
"NRBQKRNB",
"NRQNBBKR",
"RKBQNBNR",
"QNBRKNRB",
"NBRKBRNQ",
"NNRBBKQR",
"NNRQKRBB",
"BRNKRBNQ",
"RKBQRNNB",
"RQBNKBRN",
"BBRNNKQR",
"BQRNKRNB",
"BQRKRBNN",
"RBNNBKRQ",
"NQRNKBBR",
"BQNRNBKR",
"QBBNRNKR",
"RKBNRNQB",
"RBKNBRNQ",
"BQRKNRNB",
"QBRKNNBR",
"BNNBRKQR",
"RQKRNNBB",
"QBRNBKNR",
"NRKBBQNR",
"RBKQBNRN",
"NBNRKRBQ",
"QBRNBKRN",
"BRKRNBNQ",
"NRKQBBRN",
"RNNKRQBB",
"BRNBKNQR",
"NBBRNKQR",
"NRNKRBBQ",
"RBKRBQNN",
"RQNKRNBB",
"NQRKBBRN",
"BBRKRNNQ",
"RNQKBRNB",
"BBRNKQRN",
"NBBQRKNR",
"RNNBKRBQ",
"BQRBNKRN",
"RNBBQNKR",
"QNBRKBNR",
"NRKNBBQR",
"RQKBBNNR",
"BRKRNBQN",
"RKNQRNBB",
"RQNKNBBR",
"RNKBRNBQ",
"RKBNRBNQ",
"BRQNKBRN",
"RKBQRBNN",
"NRBQNBKR",
"RNKQNBBR",
"BRNNKRQB",
"QRNKRBBN",
"BRKBNNQR",
"RKRQNNBB",
"QBNRBKRN",
"RNKRQBBN",
"RNBQKRNB",
"NNRQBKRB",
"RBNKBQRN",
"RKQBNRBN",
"RKQNBBRN",
"NRNKBRQB",
"BNRQNBKR",
"RQNNBKRB",
"BNRKQNRB",
"QRKNNBBR",
"RKQNBNRB",
"BRQNKRNB",
"RKNRBBQN",
"BBRKNQNR",
"BNRQNKRB",
"RBBKRQNN",
"RKQNNBBR",
"RBQNBNKR",
"QRNKBNRB",
"BNRBNKRQ",
"RNBKQBNR",
"RKRQNBBN",
"RNKQNRBB",
"QRBBKRNN",
"BNRNKBQR",
"NBQRBNKR",
"QNRNKRBB",
"RKNNBBQR",
"RQBBNNKR",
"RQBBKRNN",
"QRKNBBRN",
"NQBBRKNR",
"NQBBRNKR",
"RBNKBRQN",
"NQBRKRNB",
"NBRNKRBQ",
"NNQRBBKR",
"NRKRBQNB",
"NRBBKQRN",
"BNQRKNRB",
"BNQNRBKR",
"NRKNRBBQ",
"BNQBRKRN",
"NQNRBBKR",
"RNBKQBRN",
"NRBQKNRB",
"RNBBQKRN",
"QNBBRKRN",
"RBBQNNKR",
"NRNQBBKR",
"QNNBBRKR",
"RBKNBQRN",
"RNBNKBQR",
"RQNBKNBR",
"NBQRKNBR",
"NRQBKNBR",
"NNBBRKRQ",
"NQNBBRKR",
"BRKBQRNN",
"RNKRNBBQ",
"BBNQNRKR",
"BRKNNRQB",
"NBBRQKNR",
"RNKBBRNQ",
"NBBQRNKR",
"NRNKQRBB",
"RKNQBNRB",
"RBBNQNKR",
"BRNQKBNR",
"RBNKQNBR",
"RKQNRNBB",
"RKBNNBQR",
"NRNBBQKR",
"NRNBQKBR",
"NQRNBKRB",
"QBBNRKNR",
"BNRBKRNQ",
"BNQBRNKR",
"NBRQBKNR",
"NRBKRNQB",
"RNQNKBBR",
"NNRKBBQR",
"BRKBRQNN",
"QBRKRNBN",
"QRKBRNBN",
"QRBBKNNR",
"RKQNBRNB",
"NRBBQNKR",
"RNKNQBBR",
"QBRNKNBR",
"RKNRNQBB",
"RBBNKRQN",
"NQBBNRKR",
"BBQNRKRN",
"QRKNRNBB",
"BNRKNBRQ",
"NBRKRNBQ",
"NQBRKBRN",
"NRQNBKRB",
"QBNNRKBR",
"BBQRNKNR",
"RQKNBNRB",
"BNNRQBKR",
"BRQKNBRN",
"BRNQNBKR",
"QNBRNKRB",
"BBNRQNKR",
"BBNQRKRN",
"RBQNKNBR",
"QBRNNKBR",
"RNQKBNRB",
"BBRNNQKR",
"BRKBNQRN",
"RKNBBQNR",
"BBRKNRNQ",
"NBNQBRKR",
"BRNQKNRB",
"NBBRQNKR",
"NRBBQKRN",
"QRKNBBNR",
"QNRNBBKR",
"BBRQKNNR",
"BRQNNKRB",
"RNNKBRQB",
"RNBBKRNQ",
"NBBRKQNR",
"BBNNRKQR",
"RKBQNBRN",
"BRKQRBNN",
"BRNNKQRB",
"QBRKBNNR",
"NBBQRKRN",
"NQNBRKBR",
"QBBRNKNR",
"BRKBNNRQ",
"RKBNQBNR",
"RBBQNKNR",
"NQRKBRNB",
"RKNBNQBR",
"BBQRKRNN",
"NQBBRKRN",
"BRNKNRQB",
"RBNKBNQR",
"QRKRBNNB",
"RKRNBBQN",
"BRKBNRQN",
"BBRNKRNQ",
"QRKNNRBB",
"RBNKBNRQ",
"NQBRNBKR",
"NNRBKRBQ",
"RQNKBBRN",
"QBNRKRBN",
"QNNRBKRB",
"RNKRBQNB",
"NRKQRBBN",
"NRQKBRNB",
"RQBNNKRB",
"QRKBBNNR",
"QRKRNBBN",
"NNQRKBBR",
"NRBBKQNR",
"RBKNBNQR",
"BQRNNBKR",
"BNRNKBRQ",
"QNRKBBNR",
"NNBRQBKR",
"RBKRQNBN",
"QRKNBRNB",
"RQNBNKBR",
"NNQRKRBB",
"QNNRBBKR",
"QRKBNNBR",
"RBBNKNQR",
"RNKBBQNR",
"NRNQBKRB",
"BRQKNRNB",
"RKNNRQBB",
"QBNRBKNR",
"BNRKRNQB",
"BRQKNBNR",
"BQRNKBNR",
"NQBRKBNR",
"RKBQNNRB",
"NRQBBNKR",
"QRKRNNBB",
"RBNKNQBR",
"NRBNKRQB",
"RQNKNRBB",
"RNKBBNRQ",
"RKNNBQRB",
"RKNBBNRQ",
"NRKRQBBN",
"BNRQKNRB",
"RNKQRNBB",
"RKNBBRNQ",
"NRBNKBQR",
"RBBNQKRN",
"RKBRQNNB",
"NRNQKRBB",
"RNKNBBRQ",
"RBKNQRBN",
"RNBNQKRB",
"QRNKBRNB",
"BNRNKRQB",
"NRNKBQRB",
"BQNBNRKR",
"RNKRBBNQ",
"BRQKNNRB",
"RKBNNQRB",
"NBRNBKQR",
"RQNBBKNR",
"RKBNQBRN",
"RBBKNQNR",
"BRNKNBRQ",
"QBBRKNRN",
"BRKNNBQR",
"QRNNBKRB",
"BBRNKQNR",
"RQKBRNBN",
"QNRKBRNB",
"RNKRBNQB",
"BRNNQBKR",
"BBRKRNQN",
"QNBBNRKR",
"QBRNBNKR",
"NNBBRKQR",
"NRBQKBNR",
"QNRBBKNR",
"RNNKBQRB",
"RQBNNBKR",
"NBNRQKBR",
"BRKBRNQN",
"BBRNQNKR",
"NBQNBRKR",
"RBBNKQNR",
"RBBNKQRN",
"NNBQRKRB",
"BNRBKRQN",
"RBKNNRBQ",
"RKNBQRBN",
"QRKBBNRN",
"QBNRNKBR",
"NBRKBQRN",
"QBBRNNKR",
"BRNKRNQB",
"NQBRNKRB",
"RNKNBRQB",
"QRBKRBNN",
"NRKBNQBR",
"RBBKQNRN",
"NRQKBBNR",
"BRKQNBNR",
"RBNQKNBR",
"NBQRNKBR",
"RNBQKBNR",
"QNRNBKRB",
"RNNQBBKR",
"BNRKRBNQ",
"RBNKNRBQ",
"RBBKRNQN",
"NRBBKRQN",
"NBBQNRKR",
"RNBNQBKR",
"RBBKNRNQ",
"RKQBRNBN",
"RKBRNNQB",
"BRKNRBNQ",
"BQRNKNRB",
"RKRBQNBN",
"RNKRQNBB",
"RNBKNBQR",
"RNKNRQBB",
"RNQBKNBR",
"BBRNQKNR",
"BBQNNRKR",
"RBBNKRNQ",
"RBQKBNRN",
"RQBNKRNB",
"QBRKBRNN",
"NRKRQNBB",
"RBNNKQBR",
"RQBBNKRN",
"BRNKQBRN",
"NNBRKQRB",
"RNQKNBBR",
"RNBQKNRB",
"BRNBKQRN",
"RKBRNQNB",
"QNNRKRBB",
"RKNNQRBB",
"BBNRQKNR",
"NRBQNKRB",
"NRBNQKRB",
"QRBBNKRN",
"NBRKQRBN",
"BQNBRKNR",
"RKNRQNBB",
"RNKNRBBQ",
"BBNRKQNR",
"RKNRBNQB",
"NRKBRQBN",
"NRKNBBRQ",
"NRKRBBQN",
"NRBBQKNR",
"BNRBKQRN",
"QBRNKRBN",
"BBRKQRNN",
"RKRQBBNN",
"QRNKBBRN",
"NRKBBNQR",
"NRBBKRNQ",
"BNRBKQNR",
"RKNBBNQR",
"BRQBKNRN",
"QNBRKRNB",
"RNQBKRBN",
"NNBQRBKR",
"BRKNRNQB",
"NRBKNBQR",
"RQNKBRNB",
"BNRBKNRQ",
"RNNQKBBR",
"RNBQKBRN",
"BRNNKBQR",
"BBRKRQNN",
"RBKNBQNR",
"NQRKRBBN",
"RBBKQNNR",
"NRBNKBRQ",
"NRBNQBKR",
"NBQRKRBN",
"NRKBBNRQ",
"NQBRKNRB",
"BBNQRNKR",
"BBRKQNNR",
"NNRQKBBR",
"RBNNKRBQ",
"RNBKQNRB",
"RNBKQRNB",
"QBRKNRBN",
"QRBNKBNR",
"NBBNRKRQ",
"QRKBNRBN",
"RKQRNBBN",
"BNRKNBQR",
"QBBRKNNR",
"QBBNRKRN",
"BQRKNBNR",
"RNBKNRQB",
"RQNKRBBN",
"RNBBNQKR",
"RBNKRQBN",
"BNQRKRNB",
"NBNRBKRQ",
"NNRBBKRQ",
"RKQRBBNN",
"RNQNBKRB",
"RKQBBNNR",
"BBNNQRKR",
"NRNBBKQR",
"NRKNRQBB",
"NQRKNBBR",
"NRBKRQNB",
"RBKNBNRQ",
"BRNQNKRB",
"BRKBNQNR",
"QRKNRBBN",
"RNQBBKRN",
"QRBNNBKR",
"BBRKNNQR",
"RNKQBBRN",
"QNNRKBBR",
"NQBNRBKR",
"NRQKRNBB",
"NRKQRNBB",
"BBQRKNRN",
"BQNBRNKR",
"BRNKQRNB",
"RBNQNKBR",
"NRBKNRQB",
"NBRQNKBR",
"RNBQNBKR",
"RBQKNNBR",
"BRKNNBRQ",
"NRKNBQRB",
"RKBNRBQN",
"RQKNBBRN",
"NQRNKRBB",
"NRQBBKNR",
"BNRBQKNR",
"RBNKRNBQ",
"NQNRBKRB",
"RNNKBBRQ",
"NBRKQNBR",
"BBRNQKRN",
"RNBBNKRQ",
"QNRKNBBR",
"RKNBBRQN",
"RBKNRNBQ",
"NRBBNQKR",
"BBRNNKRQ",
"RNKBNRBQ",
"BNRBKNQR",
"NBBRNQKR",
"NRNBBKRQ",
"RKNBNRBQ",
"RKBBNNRQ",
"RNKBQRBN",
"RBNNBKQR",
"RNNBKQBR",
"NRQKBNRB",
"NNRBKQBR",
"RKRBBNNQ",
"QRNKBBNR",
"RBKQRNBN",
"RNQNBBKR",
"NRKQNRBB",
"QNRNKBBR",
"NNRKQBBR",
"RNQKRBBN",
"BQRNNKRB",
"RKQBBNRN",
"RQKNBBNR",
"RBBNQKNR",
"NRKRBBNQ",
"QRBNKNRB",
"RKRNQBBN",
"RKNBRQBN",
"RNBBKQRN",
"NBRQKNBR",
"QNBRKBRN",
"RBQNBKRN",
"NBBRKNQR",
"NBQNRKBR",
"NRQKNBBR",
"RKBBNRNQ",
"QBNRKNBR",
"QNBRNBKR",
"RBBQKNRN",
"RNNKBBQR",
"NRBKRBQN",
"BQRBKNNR",
"BRNKRBQN",
"NRQBBKRN",
"BRNKQNRB",
"NQRKBBNR",
"RNKBBRQN",
"QRNNBBKR",
"BRKRNQNB",
"RBBKNQRN",
"RBBQNKRN",
"QRBBNNKR",
"BBRNKNRQ",
"RBKRBNNQ",
"BRKRQBNN",
"QRNBBNKR",
"RKBBRNNQ",
"BNQRKBNR",
"QRNBKRBN",
"NRQKRBBN",
"QNBNRBKR",
"BRNBNKQR",
"BBRNKRQN",
"BNRBQKRN",
"NBNRKQBR",
"RKBRNBQN",
"BNQRNKRB",
"RBNQBKNR",
"QRBBNKNR",
"QNRBKNBR",
"NRNKQBBR",
"BQRKNNRB",
"RKBBRNQN",
"RNBNKQRB",
"QRBKNBNR",
"NRKQNBBR",
"BBNNRKRQ",
"BBRNKNQR",
"RBNKBRNQ",
"RQBBKNNR",
"RNBKRBNQ",
"BRQNKBNR",
"NNBBQRKR",
"NRBBNKQR",
"NNRQBBKR",
"NRQBNKBR",
"RNKRBBQN",
"RBBNNQKR",
"BRNQKRNB",
"RBBNNKQR",
"BBQNRKNR",
"RKBBRQNN",
"NNRKBQRB",
"BRNBNQKR",
"RNBBQKNR",
"NRKQBRNB",
"RKBBQNNR",
"RNKQBRNB",
"RNQKRNBB",
"QRBNKRNB",
"QNRKBBRN",
"RKNBQNBR",
"RQBBNKNR",
"BNQRNBKR",
"RNBBKQNR",
"BRNKNQRB",
"NRQNKBBR",
"RNKNBQRB",
"NRKBQRBN",
"RQNNBBKR",
"RQBNKBNR",
"NQNRKBBR",
"RBKRNNBQ",
"RKNNBRQB",
"RKQNBBNR",
"RKRBBNQN",
"RKBNNBRQ",
"BNRQKBNR",
"BNRNKQRB",
"BRKNRQNB",
"RBKNNQBR",
"BNNQRKRB",
"RQKBNRBN",
"NRBBNKRQ",
"QNNBRKBR",
"BRKBQNRN",
"BRNBKQNR",
"NNRBQKBR",
"NBRNQKBR",
"NRNBKRBQ",
"BNRNQBKR",
"RNKNBBQR",
"BQNRKRNB",
"NRBKQBRN",
"RQKNNBBR",
"BQNRKBRN",
"RNQNKRBB",
"RNNKQBBR",
"QRKRBBNN",
"NNRKBBRQ",
"NRKBBQRN",
"RQBKNNRB",
"RNBBNKQR",
"QNBNRKRB",
"RKRNNQBB",
"BQNRNKRB",
"BBNRKRQN",
"QNRBBKRN",
"BBRQNKRN",
"BQRBNKNR",
"NBNQRKBR",
"BRKBRNNQ",
"RKNRBQNB",
"BRQBKRNN",
"RNNQKRBB",
"NRKBBRQN",
"NNBRKBQR",
"BQRBKRNN",
"BNNRQKRB",
"NNRBBQKR",
"NBRKRQBN",
"QBBRNKRN",
"RKQRBNNB",
"RNNKRBBQ",
"RNBKRNQB",
"NNBRQKRB",
"RNKBQNBR",
"NBRQBNKR",
"RKBNRQNB",
"RKQBNNBR",
"BNQNRKRB",
"NNRKRBBQ",
"RQBKRNNB",
"NRBKNQRB",
"QNBBRNKR",
"BQRKNBRN",
"NBRQBKRN",
"NBNRBKQR",
"BRKNQNRB",
"BRQBNKNR",
"BRKNRBQN",
"BRNBNKRQ",
"RKNNBBRQ",
"QRNKNBBR",
"NQRNBBKR",
"BBRKNRQN",
"NNRKRQBB",
"BBNRKNQR",
"BRKQNRNB",
"RQBKNBRN",
"BRKNQBNR",
"RKNRQBBN",
"BNRKRQNB",
"RKRQBNNB",
"QNRBNKBR",
"RBKQNRBN",
"NNBBRQKR",
"QRNNKRBB",
"NRKRNQBB",
"RKNQBBRN",
"RKBNNRQB",
"RNBQNKRB",
"BBRKQNRN",
"NRNQKBBR",
"RKNQBRNB",
"NBBNQRKR",
"BRNBKRNQ",
"NRQKNRBB",
}
;
int ask(int j1, int j2)
{
    int ans = 0;
    for (int i=0; i<8; i++)
        if (pos[j1][i] == pos[j2][i])
            ans++;
    return ans;
}

int id = 0;
int ask(int id1)
{
    cout<<pos[id1]<<endl;
    int ans;
    cin>>ans;
    return ans;
//    return ask(id, id1);
}

void solve()
{
    vector<int> lt;
    for (int i=0; i<960; i++) lt.pb(i);
    int cnt = 0;
    while (true)
    {
        pair<int, int> mn = {1e9, -1};
        for (int ci=0; ci<min<int>(50, lt.size()); ci++)
        {
            int i = lt[ci];
            vector<int> ans(9);
            for (int j : lt)
                ans[ask(i, j)]++;
            int mx = 0;
            for (int j : ans)
                mx = max(mx, j);
            mn = min(mn, {mx, i});
        }

        cnt++;
        int i = mn.se;
        int a = ask(i);
        if (a == 8)
            break;

        vector<int> nw;
        for (int j : lt)
            if (ask(j, i) == a)
                nw.pb(j);
        lt = nw;
    }

//    if (cnt > 6)
//        cout<<lt[0]<<" "<<cnt<<"\n";
}

main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
//    cout<<pos.size()<<"\n";

//    for (id=0; id<960; id++)
//        solve();
//    return 0;

    while (true)
    {
        string s;
        cin>>s;
        if (s == "GAME")
        {
            int n;
            cin>>n;
            solve();
        }
        else
            return 0;
    }
}