#include <cstring>
#include <functional>
#include <iostream>
#include <vector>
#include <queue>
#include <stack>
using namespace std;
const int N = 2e5 + 10, M = 20 * N, INF = 0x3f3f3f3f;

int T, n, m;

vector<int> getsz(int n, const vector<vector<int>> &g) {
    vector<int> sz(n + 1);
    function<void(int)> dfs = [&](int u) {
        if (g[u].empty()) {
            sz[u] = 1;
            return;
        }
        for (int v : g[u]) {
            dfs(v);
            sz[u] += sz[v];
        }
    };
    dfs(n);
    return sz;
}

int s, t;

struct qxx {
    int nex, t, v;
};

qxx e[M];
int h[N], cnt;

void addedge(int f, int t, int v) { e[++cnt] = (qxx){h[f], t, v}, h[f] = cnt; }

int ht[N + 1], ex[N + 1],
    gap[N];      // 高度; 超额流; gap 优化 gap[i] 为高度为 i 的节点的数量
stack<int> B[N]; // 桶 B[i] 中记录所有 ht[v]==i 的v
int level;   // 溢出节点的最高高度

int push(int u) {       // 尽可能通过能够推送的边推送超额流
    bool init = u == s; // 是否在初始化
    for (int i = h[u]; i; i = e[i].nex) {
        const int &v = e[i].t, &w = e[i].v;
        if (!w || init == false && ht[u] != ht[v] + 1 ||
            ht[v] == INF) // 初始化时不考虑高度差为1
            continue;
        int k = init ? w : min(w, ex[u]);
        // 取到剩余容量和超额流的最小值，初始化时可以使源的溢出量为负数。
        if (v != s && v != t && !ex[v])
            B[ht[v]].push(v), level = max(level, ht[v]);
        ex[u] -= k, ex[v] += k, e[i].v -= k, e[i ^ 1].v += k; // push
        if (!ex[u])
            return 0; // 如果已经推送完就返回
    }
    return 1;
}

void relabel(int u) { // 重贴标签（高度）
    ht[u] = INF;
    for (int i = h[u]; i; i = e[i].nex)
        if (e[i].v)
            ht[u] = min(ht[u], ht[e[i].t]);
    if (++ht[u] < t) { // 只处理高度小于 n 的节点
        B[ht[u]].push(u);
        level = max(level, ht[u]);
        ++gap[ht[u]]; // 新的高度，更新 gap
    }
}

bool bfs_init() {
    memset(ht, 0x3f, sizeof(int) * (t + 1));
    queue<int> q;
    q.push(t), ht[t] = 0;
    while (q.size()) { // 反向 BFS, 遇到没有访问过的结点就入队
        int u = q.front();
        q.pop();
        for (int i = h[u]; i; i = e[i].nex) {
            const int &v = e[i].t;
            if (e[i ^ 1].v && ht[v] > ht[u] + 1)
                ht[v] = ht[u] + 1, q.push(v);
        }
    }
    return ht[s] != INF; // 如果图不连通，返回 0
}

int select() {
    while (B[level].size() == 0 && level > -1)
        level--;
    return level == -1 ? 0 : B[level].top();
}

int hlpp() { // 返回最大流
    if (!bfs_init())
        return 0; // 图不连通
    memset(gap, 0, sizeof(int) * (t + 1));
    for (int i = 1; i <= t; i++)
        if (ht[i] != INF)
            gap[ht[i]]++; // 初始化 gap
    ht[s] = t;
    push(s); // 初始化预流
    int u;
    while ((u = select())) {
        B[level].pop();
        if (push(u)) { // 仍然溢出
            if (!--gap[ht[u]])
                for (int i = 1; i <= t; i++)
                    if (i != s && ht[i] > ht[u] && ht[i] < t + 1)
                        ht[i] = t + 1; // 这里重贴成 n+1 的节点都不是溢出节点
            relabel(u);
        }
    }
    return ex[t];
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> T;
    while (T--) {
        level = 0;
        cnt = 1;
        cin >> n >> m;
        s = n + m + 1;
        t = n + m + 2;
        memset(h + 1, 0, sizeof(int) * t);
        memset(ex + 1, 0, sizeof(int) * t);
        vector<vector<int>> g(n + 1), h(m + 1);
        vector<int> gfa(n + 1), hfa(m + 1);
        for (int i = 1; i < n; i++) {
            int p;
            cin >> p;
            gfa[i] = p;
            g[p].emplace_back(i);
        }
        for (int i = 1; i < m; i++) {
            int q;
            cin >> q;
            hfa[i] = q;
            h[q].emplace_back(i);
        }
        vector<int> gsz = getsz(n, g);
        vector<int> hsz = getsz(m, h);
        int k = gsz[n];
        for (int i = 1; i < n; i++) {
            if (gsz[i] & 1) {
                addedge(i, gfa[i], 1);
                addedge(gfa[i], i, 0);
            }
        }
        if (k & 1) {
            addedge(n, n + m, 1);
            addedge(n + m, n, 0);
        }
        for (int i = 1; i < m; i++) {
            if (hsz[i] & 1) {
                addedge(n + hfa[i], n + i, 1);
                addedge(n + i, n + hfa[i], 0);
            }
        }
        vector<int> cid(k + 1);
        for (int i = 1; i <= k; i++) {
            addedge(n + i, i, 1);
            addedge(i, n + i, 0);
            cid[i] = cnt;
        }
        int expect = 0;
        for (int i = k + 1; i <= n; i++) {
            int sum = 0;
            for (int j : g[i])
                sum += gsz[j] >> 1;
            sum -= gsz[i] >> 1;
            if (sum > 0) {
                expect += sum;
                addedge(s, i, sum);
                addedge(i, s, 0);
            } else if (sum < 0) {
                addedge(i, t, -sum);
                addedge(t, i, 0);
            }
        }
        for (int i = k + 1; i <= m; i++) {
            int sum = hsz[i] >> 1;
            for (int j : h[i])
                sum -= hsz[j] >> 1;
            if (sum > 0) {
                expect += sum;
                addedge(s, n + i, sum);
                addedge(n + i, s, 0);
            } else if (sum < 0) {
                addedge(n + i, t, -sum);
                addedge(t, n + i, 0);
            }
        }
        if (hlpp() != expect) {
            cout << "IMPOSSIBLE\n";
            continue;
        }
        for (int i = 1; i <= k; i++)
            cout << (e[cid[i]].v ? 'R' : 'B');
        cout << '\n';
    }
    return 0;
}