#include <cstring>
#include <functional>
#include <iostream>
#include <vector>
#include <queue>
#include <stack>
using namespace std;
const int N = 1e5 + 10;

int T, n, m;

vector<int> getsz(int n, const vector<vector<int>> &g) {
    vector<int> sz(n + 1);
    for (int i = 1; i <= n; i++) {
        if(g[i].empty())
            sz[i] = 1;
        for(int j : g[i])
            sz[i] += sz[j];
    }
    return sz;
}

int s, t, cnt, head[N * 2];

struct Node
{
    int v;//当前点 
    int next;//连接点 
    int val;//容量 
}node[N * 40];//node[i]:第i条边的情况 
inline void addedge(int u,int v,int val)
{
    node[++cnt].v=v;
    node[cnt].val=val;
    node[cnt].next=head[u];
    head[u]=cnt;
}
int dep[N * 2],gap[N * 2];//dep[i]表示节点i的深度，gap[i]表示深度为i的点的数量 
void bfs()//倒着搜 
{
    memset(dep,-1,sizeof(int) * (t + 1));//把深度变为-1(0会导致gap崩坏) 
    memset(gap,0,sizeof(int) * (t + 1));
    dep[t]=0;//汇点深度为0 
    gap[0]=1;//深度为0的点有1个 
    queue<int>q; 
    q.push(t);//t点入栈 
    while(!q.empty())
	{
        int u=q.front();
        q.pop();
        for(int i=head[u];i;i=node[i].next)//head[u]:u点所在的边,node[i].next:u点所在的边的下一个点，就这样遍历下去 
		{
            int v=node[i].v;//v为当前边的下一个点 
            if(dep[v]!=-1)	continue;//dep[v]!=-1相当于v点已被遍历||不管 
            q.push(v);
            dep[v]=dep[u]+1;//v点的深度比u点大1 
            gap[dep[v]]++;
        }//直到所有点都被遍历过 
    }
    return;
}//从t到s跑一遍bfs，标记深度
long long maxflow;
int dfs(int u,int flow)
{
    if(u==t)
	{
        maxflow+=flow;
        return flow;
    }
    int used=0;
    for(int i=head[u];i;i=node[i].next)//head[u]:u点所在的边,node[i].next:u点所在的边的下一个点，就这样遍历下去 
	{
        int d=node[i].v;
        if(node[i].val&&dep[d]+1==dep[u])//如果这条边的残量大于0,且没有断层 
		{
            int mi=dfs(d,min(node[i].val,flow-used));
            if(mi){
                node[i].val-=mi;
                node[i^1].val+=mi;
                used+=mi;
            }
            if(used==flow)return used;
        }
    }
    //如果已经到了这里，说明该点出去的所有点都已经流过了
    //并且从前面点传过来的流量还有剩余
    //则此时，要对该点更改dep
    //使得该点与该点出去的点分隔开
    --gap[dep[u]];
    if(gap[dep[u]]==0)dep[s]=t+1;//出现断层，无法到达t了
    dep[u]++;//层++ 
    gap[dep[u]]++;//层数对应个数++
    return used; 
}
long long ISAP()
{
    maxflow=0;
    bfs();
    while(dep[s]<t)	dfs(s,0x3f3f3f3f);//每走一遍增广路,s的层数会加1,如果一直没有出现断层,最多跑n-dep(刚bfs完时s的深度)条增广路共有n个点 
    return maxflow;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> T;
    while (T--) {
        cnt = 1;
        cin >> n >> m;
        s = n + m + 1;
        t = n + m + 2;
        memset(head + 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);
        vector<int> gb(n + 1), hb(m + 1);
        int k = gsz[n];
        int expect = 0;
        gb[n] = k >> 1;
        for (int i = n; i > 0; i--) {
            int sum = -gb[i];
            bool flag = false;
            for(int j : g[i]) {
                if(gsz[j] & 1) {
                    gb[j] = (gsz[j] >> 1) + flag;
                    addedge(j, i, flag ^ 1);
                    addedge(i, j, flag);
                    flag ^= 1;
                }
                else
                    gb[j] = gsz[j] >> 1;
                sum += gb[j];
            }
            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);
            }
        }
        hb[m] = k >> 1;
        for (int i = m; i > 0; i--) {
            int sum = hb[i];
            bool flag = false;
            for(int j : h[i]) {
                if(hsz[j] & 1) {
                    hb[j] = (hsz[j] >> 1) + flag;
                    addedge(n + j, n + i, flag);
                    addedge(n + i, n + j, flag ^ 1);
                    flag ^= 1;
                }
                else
                    hb[j] = hsz[j] >> 1;
                sum -= hb[j];
            }
            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);
            }
        }
        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;
        }
        if (k & 1) {
            addedge(n, n + m, 1);
            addedge(n + m, n, 0);
        }
        if (ISAP() != expect) {
            cout << "IMPOSSIBLE\n";
            continue;
        }
        for (int i = 1; i <= k; i++)
            cout << (node[cid[i]].val ? 'R' : 'B');
        cout << '\n';
    }
    return 0;
}