#include<iostream>
#include<cstring>
#include<vector>
#include<set>
#include<queue>
#include<numeric>
#include<cassert>
#include<algorithm>
using namespace std;
using LL = long long;

struct DSU{
    vector<int> p;
    DSU(int n) : p(n + 1){
        iota(p.begin(), p.end(), 0);
    }

    int find(int x){
        return p[x] == x ? x : p[x] = find(p[x]);
    }

    bool same(int x, int y) { 
        return find(x) == find(y); 
    }

    bool merge(int x, int y){
        x = find(x), y = find(y);
        if (x == y) return false;
        p[y] = x;
        return true;
    }
};

int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);

    int T;
    cin >> T;
    while(T--){
        int n, m;
        cin >> n >> m;
        vector<vector<int> > g(n);
        vector<pair<int, int> > edge(m);
        for(int i = 0; i < m; i++){
            int a, b;
            cin >> a >> b;
            g[a].push_back(b);
            g[b].push_back(a);
            edge[i] = {a, b};
        }
        for(int i = 0; i < n; i++){
            int a = i, b = (i + 1) % n;
            g[a].push_back(b);
            g[b].push_back(a);
            edge.push_back({a, b});
        }

        vector<int> d(n);
        for(auto [a, b] : edge){
            d[a] += 1;
            d[b] += 1;
        }
        vector<bool> del(n);

        vector<int> v;

        for(int i = 0; i < n; i++){
            if (d[i] <= 2){
                del[i] = true;
                v.push_back(i);
            }
        }

        vector<int> order, id(n);
        int cnt = 0;
        while(!v.empty()){
            for(auto x : v){
                order.push_back(x);
                id[x] = cnt;
            }
            cnt++;
            vector<int> nv;
            for(auto x : v){
                for(auto j : g[x]){
                    if (--d[j] <= 2 and !del[j]){
                        del[j] = true;
                        nv.push_back(j);
                    }
                }
            }
            v.swap(nv);
        }

        reverse(order.begin(), order.end());
        vector<int> color(n, -1);
        for(auto x : order){
            if (color[x] != -1) continue;
            queue<int> q;
            q.push(x);
            color[x] = 0;
            while(!q.empty()){
                int t = q.front();
                q.pop();
                for(auto j : g[t]){
                    if (id[j] == id[t] or id[j] == id[t] - 1){
                        if (color[j] == -1){
                            color[j] = color[t] ^ 1;
                            q.push(j);
                        }
                    }
                }
            }
        }

        for(auto x : color) cout << (x ? 'R' : 'B');
        cout << '\n';

        auto check = [&](){
            DSU dsu(n);
            for(auto [a, b] : edge){
                if (color[a] == color[b]){
                    if (dsu.same(a, b)){
                        return false;
                    }
                    dsu.merge(a, b);
                }
            }
            return true;
        };
        // if (!check()){
        //     for(auto [a, b] : edge){
        //         cout << a << ' ' << b << '\n';
        //     }
        //     return 1;
        // }
        assert(check());
    }

}