const RED: &'static str = "Red";
const BLUE: &'static str = "Blue";

fn main() {
    let (r, w) = (std::io::stdin(), std::io::stdout());
    let mut sc = IO::new(r.lock(), w.lock());

    // use rand::seq::SliceRandom;
    // let mut rng = rand::thread_rng();
    // let n = 99;
    // for i in 1.. {
    //     let mut ans = vec![false; n * 2];
    //     let mut x = (0..(2 * n)).collect::<Vec<usize>>();
    //     x.shuffle(&mut rng);
    //     for i in 0..n {
    //         ans[x[i]] = true;
    //     }
    //
    //     let result = solve(n, |prefix, suffix| is_true(prefix, suffix, &ans));
    //     assert_eq!(result, ans);
    //
    //     if i % 1000 == 0 {
    //         println!("{}", i);
    //     }
    // }

    let n: usize = sc.read();
    let colors = solve(n, move |prefix, suffix| {
        print_set(prefix, suffix);
        match sc.read::<String>().as_str() {
            RED => true,
            BLUE => false,
            _ => unreachable!(),
        }
    });

    print!("! ");
    for i in 0..(2 * n) {
        if colors[i] {
            print!("R");
        } else {
            print!("B");
        }
    }
    println!();
}

fn is_true(prefix: &[usize], suffix: &[usize], ans: &[bool]) -> bool {
    assert_eq!((prefix.len() + suffix.len()) * 2, ans.len());
    let mut count = 0;
    for &i in prefix.iter() {
        if ans[i] {
            count += 1;
        }
    }
    for &i in suffix.iter() {
        if ans[i] {
            count += 1;
        }
    }
    count * 2 > prefix.len() + suffix.len()
}

fn solve<F: FnMut(&[usize], &[usize]) -> bool>(n: usize, mut is_red: F) -> Vec<bool> {
    let first = is_red(&(0..n).collect::<Vec<_>>(), &vec![]);
    let mut prefix = 0;
    let mut suffix = n;

    while suffix - prefix > 1 {
        let m = (suffix + prefix) / 2;
        if is_red(&(m..(m + n)).collect::<Vec<_>>(), &vec![]) == first {
            prefix = m;
        } else {
            suffix = m;
        }
    }

    let mut colors = vec![None; 2 * n];
    colors[prefix] = Some(first);
    colors[prefix + n] = Some(!first);
    let base = ((prefix + 1)..(prefix + n)).collect::<Vec<_>>();
    assert_eq!(base.len() + 1, n);
    for i in 0..(2 * n) {
        if base.contains(&i) {
            continue;
        }
        if colors[i].is_some() {
            continue;
        }
        colors[i] = Some(is_red(&base, &vec![i]));
    }

    let mut red = 0;
    let mut blue = 0;
    let mut base = vec![];
    for i in 0..(2 * n) {
        if let Some(is_red) = colors[i] {
            if is_red && red * 2 + 1 < n {
                red += 1;
                base.push(i);
            }
            if !is_red && blue * 2 + 1 < n {
                blue += 1;
                base.push(i);
            }
        }
    }

    assert_eq!(base.len() + 1, n);
    for i in 0..(2 * n) {
        if colors[i].is_none() {
            colors[i] = Some(is_red(&base, &vec![i]));
        }
    }
    colors.into_iter().map(|p| p.unwrap()).collect()
}

fn print_set(prefix: &[usize], suffix: &[usize]) {
    print!("?");
    for &p in prefix.iter() {
        print!(" {}", p + 1);
    }
    for &p in suffix.iter() {
        print!(" {}", p + 1);
    }
    println!();
}

pub struct IO<R, W: std::io::Write>(R, std::io::BufWriter<W>);

impl<R: std::io::Read, W: std::io::Write> IO<R, W> {
    pub fn new(r: R, w: W) -> Self {
        IO(r, std::io::BufWriter::new(w))
    }
    pub fn write<S: ToString>(&mut self, s: S) {
        use std::io::Write;
        self.1.write(s.to_string().as_bytes()).unwrap();
    }
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .0
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}


Measured memory_bytes: 4816