#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});
        }

        auto get = [&](pair<int, int> a){
            if (a.second < a.first) swap(a.first, a.second);
            return min(a.second - a.first, n - a.second + a.first);
        };

        sort(edge.begin(), edge.end(), [&](pair<int, int> a, pair<int, int> b){
            return get(a) > get(b);
        });

        vector<int> color(n, -1);
        for(auto [l, r] : edge){
            if (color[l] == -1 and color[r] == -1){
                color[l] = 0;
                color[r] = 1;
            }            
            else if (color[r] == -1){
                color[r] = color[l] ^ 1;
            }
            else if (color[l] == -1){
                color[l] = color[r] ^ 1;
            }
        }

        // 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 : 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());
    }

}