def examA():
    N = I()
    A = LI()
    D = defaultdict(int)
    for a in A:
        D[a] += 1
    ans = 0
    for key,d in D.items():
        if key>d:
            ans += d
        else:
            ans += d - key
    print(ans)
    return

def examB():
    N = I()
    A = LI()
    S = [0]*(N+1)
    for i in range(N):
        S[i+1] = S[i]+A[i]
    D = defaultdict(int)
    for s in S:
        D[s] += 1
    ans = 0
    for d in D.values():
        ans += d*(d-1)//2
    print(ans)
    return

def examC():
    N, A, B, C = LI()
    L = [I()for _ in range(N)]
    loop = (1<<(2*N))
    ans = inf
    for l in range(loop):
        cost = 0
        bamboo_A = 0
        bamboo_B = 0
        bamboo_C = 0
        for j in range(N):
            if l&(1<<(2*j))>0:
                if l&(1<<(2*j+1))>0:
                    cost += 10
                    bamboo_A += L[j]
                else:
                    cost += 10
                    bamboo_B += L[j]
            else:
                if l&(1<<(2*j+1))>0:
                    cost += 10
                    bamboo_C += L[j]
        if bamboo_A==0 or bamboo_B==0 or bamboo_C==0:
            continue
        cost += abs(A-bamboo_A) + abs(B-bamboo_B) + abs(C-bamboo_C) - 30
        ans = min(ans,cost)

    print(ans)
    return

def examD():
    N = I()
    P = LI()
    O_ = [-1]*N
    start = P[0]-1
    for i in range(N):
        O_[P[i]-1] = i
    #print(O_,start)
    A = [1]*N
    B = [1]*N
    for i in range(start+1,N):
        cur = O_[i]-O_[i-1]
        if cur>0:
            A[i] = A[i-1] + (cur+1)
            B[i] = B[i-1] - 1
        else:
            A[i] = A[i-1] + 1
            B[i] = B[i-1] - (-cur+1)
    for i in range(start)[::-1]:
        cur = O_[i]-O_[i+1]
        if cur>0:
            B[i] = B[i+1] + (cur+1)
            A[i] = A[i+1] - 1
        else:
            B[i] = B[i+1] + 1
            A[i] = A[i+1] - (-cur+1)
    if A[0]<1:
        add = (1-A[0])
        for i in range(N):
            A[i] += add
    if B[-1]<1:
        add = (1-B[-1])
        for i in range(N):
            B[i] += add

    print(" ".join(map(str,A)))
    print(" ".join(map(str,B)))
    return

def examE():
    N = I()
    V = [[]for _ in range(N)]
    for _ in range(N-1):
        x, y = LI()
        x -= 1; y -= 1
        V[x].append(y)
        V[y].append(x)
    def dfs(s,p=-1):
        loop = 0
        grundy = 0
        children = []
        for v in V[s]:
            if v==p:
                continue
            loop += 1
            children.append(dfs(v,s)+1)
        if loop==1:
            grundy = children[0]
        elif loop>1:
            for c in children:
                grundy ^= c
        return grundy
    if dfs(0):
        print("Alice")
    else:
        print("Bob")
    return

def examF():
    N = I()
    ans = [""]*(2*N)
    print("? " + " ".join(map(str,[i+1 for i in range(N)])))
    base = str(input())
    l = 1; r = N+1
    while(r-l>1):
        now = (l+r)//2
        rep = [i+now for i in range(N)]
        print("? " + " ".join(map(str,rep)))
        res = str(input())
        if base==res:
            l = now
        else:
            r = now

    R = []; B = []
    if base=="Red":
        ans[l-1] = "R"
        ans[l+N-1] = "B"
        R.append(l-1); B.append(l+N-1)
    else:
        ans[l-1] = "B"
        ans[l+N-1] = "R"
        B.append(l-1); R.append(l+N-1)

    #print(ans)

    for i in range(2*N):
        if l<=i+1<=l+N:
            continue
        rep = [k+l+1 for k in range(N-1)]
        rep.append(i+1)
        print("? " + " ".join(map(str,rep)))
        res = str(input())
        if res=="Red":
            ans[i] = "R"
            R.append(i)
        elif  res=="Blue":
            ans[i] = "B"
            B.append(i)
        else:
            print(hoge)

    check = []
    for i in range(N//2):
        check.append(R[i]+1)
        check.append(B[i]+1)

    #print(R,check)
    #print(ans)

    for i in range(2*N):
        if ans[i]!="":
            continue
        rep = check + [i+1]
        print("? " + " ".join(map(str,rep)))
        res = str(input())
        if res=="Red":
            ans[i] = "R"
        elif res=="Blue":
            ans[i] = "B"
        else:
            print(hoge)

    print("! "+"".join(map(str,ans)))
    return


from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(input())
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}

getcontext().prec = 28

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examF()

"""
9
7 3 9 1 8 4 5 6 2

3
Red
Blue
Red
Blue
Red
Blue
"""

Measured memory_bytes: 10616