import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop;

bool ask(int[] A) {
    writeln("? ", A.map!(a => (a+1).to!string).join(" "));
    stdout.flush;
    return readln.chomp == "Red";
}

void answer(int[] ans) {
    writeln("! ", ans.map!(a => a ? "R" : "B").join(""));
}

void main() {
    auto N = readln.chomp.to!int;

    if (N == 1) {
        if (ask([0])) {
            answer([1, 0]);
        } else {
            answer([0, 1]);
        }
        return;
    }

    int prev = -1;
    int idx1 = -1;
    int idx2 = -1;
    auto ans = new int[](2*N);
    auto A = iota(N*2).array;

    foreach (i; 0..2*N-N+1) {
        auto hoge = ask(A[i..i+N]);
        if (prev == -1) {
            prev = hoge;
        } else if (prev != hoge) {
            idx1 = i - 1;
            idx2 = i + N - 1;
            if (prev == 0) {
                ans[idx1] = 0;
                ans[idx2] = 1;
            } else {
                ans[idx1] = 1;
                ans[idx2] = 0;
            }
            break;
        }
        prev = hoge;
    }

    foreach (i; 0..2*N) {
        if (i >= idx1 && i <= idx2) {
            continue;
        }
        auto hoge = ask(A[idx1+1..idx2] ~ A[i]);
        if (hoge) {
            ans[i] = 1;
        } else {
            ans[i] = 0;
        }
    }

    int[] B;
    int red = 0, blue = 0;
    foreach (i; 0..2*N) {
        if (i >= idx1+1 && i <= idx2-1) {
            continue;
        }
        if (ans[i]) {
            if (red < (N - 1) / 2) {
                red += 1;
                B ~= i;
            }
        } else {
            if (blue < (N - 1) / 2) {
                blue += 1;
                B ~= i;
            }
        }
    }

    foreach (i; 0..2*N) {
        if (i >= idx1+1 && i <= idx2-1) {
            auto hoge = ask(B ~ i);
            if (hoge) {
                ans[i] = 1;
            } else {
                ans[i] = 0;
            }
        }
    }

    answer(ans);
}


