// ---------- begin quick find ----------
pub struct QuickFind {
    size: usize,
    id: Vec<usize>,
    list: Vec<Vec<usize>>,
}

impl QuickFind {
    pub fn new(size: usize) -> Self {
        let id = (0..size).collect::<Vec<_>>();
        let list = (0..size).map(|x| vec![x]).collect::<Vec<_>>();
        QuickFind { size, id, list }
    }
    pub fn root(&self, x: usize) -> usize {
        assert!(x < self.size);
        self.id[x]
    }
    pub fn same(&self, x: usize, y: usize) -> bool {
        assert!(x < self.size);
        assert!(y < self.size);
        self.root(x) == self.root(y)
    }
    pub fn unite(&mut self, x: usize, y: usize) -> Option<(usize, usize)> {
        assert!(x < self.size);
        assert!(y < self.size);
        let mut x = self.root(x);
        let mut y = self.root(y);
        if x == y {
            return None;
        }
        if (self.list[x].len(), x) < (self.list[y].len(), y) {
            std::mem::swap(&mut x, &mut y);
        }
        let mut z = std::mem::take(&mut self.list[y]);
        z.iter().for_each(|y| self.id[*y] = x);
        self.list[x].append(&mut z);
        Some((x, y))
    }
    pub fn enumerate(&self, x: usize) -> &[usize] {
        assert!(x < self.size);
        &self.list[self.root(x)]
    }
    pub fn size(&self, x: usize) -> usize {
        assert!(x < self.size);
        self.enumerate(x).len()
    }
}
// ---------- end quick find ----------
// ---------- begin scannner ----------
#[allow(dead_code)]
mod scanner {
    use std::str::FromStr;
    pub struct Scanner<'a> {
        it: std::str::SplitWhitespace<'a>,
    }
    impl<'a> Scanner<'a> {
        pub fn new(s: &'a String) -> Scanner<'a> {
            Scanner {
                it: s.split_whitespace(),
            }
        }
        pub fn next<T: FromStr>(&mut self) -> T {
            self.it.next().unwrap().parse::<T>().ok().unwrap()
        }
        pub fn next_bytes(&mut self) -> Vec<u8> {
            self.it.next().unwrap().bytes().collect()
        }
        pub fn next_chars(&mut self) -> Vec<char> {
            self.it.next().unwrap().chars().collect()
        }
        pub fn next_vec<T: FromStr>(&mut self, len: usize) -> Vec<T> {
            (0..len).map(|_| self.next()).collect()
        }
    }
}
// ---------- end scannner ----------

use std::io::Write;
use std::collections::*;

type Map<K, V> = BTreeMap<K, V>;
type Set<T> = BTreeSet<T>;
type Deque<T> = VecDeque<T>;

fn main() {
    use std::io::Read;
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();
    let mut sc = scanner::Scanner::new(&s);
    let out = std::io::stdout();
    let mut out = std::io::BufWriter::new(out.lock());
    run(&mut sc, &mut out);
}

fn run<W: Write>(sc: &mut scanner::Scanner, out: &mut std::io::BufWriter<W>) {
    let t: u32 = sc.next();
    for _ in 0..t {
        let n: usize = sc.next();
        let m: usize = sc.next();
        let p = sc.next_vec::<usize>(n - 1);
        let q = sc.next_vec::<usize>(m - 1);
        let ans = solve(n, m, p, q);
        writeln!(out, "{}", ans).ok();
    }
}

fn solve(n: usize, m: usize, p: Vec<usize>, q: Vec<usize>) -> String {
    let x = calc(n, p.clone());
    let y = calc(m, q);
    let k = p.iter().min().unwrap() - 1;
    let mut dsu = QuickFind::new(2 * k);
    for &(x, y) in x.iter().chain(y.iter()) {
        dsu.unite(x, k + y);
        dsu.unite(y, k + x);
    }
    let mut used = vec![false; 2 * k];
    let mut ans = vec![0; k];
    for i in 0..k {
        let r = dsu.root(i);
        if used[r] {
            continue;
        }
        used[r] = true;
        used[dsu.root(i + k)] = true;
        for &v in dsu.enumerate(i) {
            if v >= k {
                ans[v - k] = 1;
            }
        }
    }
    ans.iter().map(|a| if *a == 0 {'B'} else {'R'}).collect()
}

fn calc(n: usize, p: Vec<usize>) -> Vec<(usize, usize)> {
    let mut g = vec![vec![]; n];
    for (i, p) in p.iter().enumerate() {
        g[*p - 1].push(i);
    }
    let mut ans = vec![];
    let mut dp = vec![n; n];
    for v in 0..n {
        if g[v].is_empty() {
            dp[v] = v;
            continue;
        }
        let mut c = g[v].iter().map(|p| dp[*p]).collect::<Vec<_>>();
        c.retain(|c| *c < n);
        while c.len() >= 2 {
            let a = c.pop().unwrap();
            let b = c.pop().unwrap();
            ans.push((a, b));
        }
        dp[v] = c.pop().map_or(n, |p| p);
    }
    ans
}