import java.io._
import java.util.StringTokenizer
import scala.util.control.Breaks.{breakable,break}
import scala.collection.mutable.{Map, Stack, Queue, PriorityQueue}

object Main extends App {
  val in = new InputReader(System.in)
  val pw = new PrintWriter(System.out)

  val N = in.next().toInt
  val ans = new Array[String](2*N+1)


  //
  val red = "Red"
  val blue = "Blue"

  def rev(color: String): String = {
    if (color == red)
      blue
    else
      red
  }

  def query(q: Seq[Int]): Unit = {
    println("? " + q.mkString(" "))
  }

  def input(): String = {
    val res = in.next()
    if (res == "-1")
      throw new RuntimeException()

    res
  }

  //
  query((1 to N).toArray)
  val left = input()


  //
  def check(i: Int): Boolean = {
    query((i-(N-1) to i).toArray)
    val res = input()

    res == rev(left)
  }

  // 条件を満たす最小の値を返す
  def binarySearch(min: Int, max: Int): Int = {
    val mid: Int = (max + min) / 2
      (max - min) match{
      case 0 | 1 =>
        check(min) match{
          case true  => min
          case false => max
        }
      case _ =>
        (check(mid)) match{
          case true  => binarySearch(min, mid)
          case false => binarySearch(mid, max)
        }
    }

  }


  //
  val r = binarySearch(N+1, 2*N)
  println(r)
  ans(r-N) = left
  ans(r) = rev(left)

  for (i <- 1 until r-N) {
    query(i +: ((r-N)+1 to r-1).toSeq)
    ans(i) = input()
  }
  for (i <- r+1 to 2*N) {
    query(i +: ((r-N)+1 to r-1).toList)
    ans(i) = input()
  }

  val hoge = (1 to (r-N)-1) ++ (r+1 to 2*N)
  for (i <- (r-N)+1 to r-1) {
    query(i +: hoge)
    ans(i) = input()
  }


  def format(color: String): String = {
    if (color == red) "R"
    else "B"
  }
  println("! " + ans.drop(1).map(format).mkString)
}

object Sub {
  def print2DimArray[A](mat: Array[Array[A]]): Unit = {
    mat.foreach(lin => println(lin.deep))
  }
}

class InputReader(stream: InputStream) {
  private[this] val reader = new BufferedReader(new InputStreamReader(stream))
  private[this] var tokenizer: StringTokenizer = new StringTokenizer(reader.readLine())
  def next(): String = {
    while (!tokenizer.hasMoreTokens()) {
      tokenizer = new StringTokenizer(reader.readLine())
    }
    tokenizer.nextToken()
  }
}
