/*{{{*/
//#define HOME
#include <bits/stdc++.h>
using namespace std;

#define MP make_pair
#define PB push_back
#define EB emplace_back
#define F first
#define S second

template<class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template<class T, class... U> void R(T &head, U &... tail) { _R(head); R(tail...); }

template<class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template<class T,class U> void _W(const pair<T,U> &x) {_W(x.F); putchar(' '); _W(x.S);}
template<class T> void _W(const vector<T> &x) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }
void W() {}
template<class T, class... U> void W(const T &head, const U &... tail) { _W(head); putchar(sizeof...(tail) ? ' ' : '\n'); W(tail...); }

template<class T, class... U> void DB(const T &head, const U &... tail) {
#ifdef HOME
    _W('#'); _W(head); putchar(sizeof...(tail) ? ' ' : '\n'); W(tail...);
#endif
}

#define REP(i,a,b) for (int i = (a); i <= (b); ++i)
#define REPD(i,a,b) for (int i = (a); i >= (b); --i)
#define FORI(i,n) REP(i,1,n)
#define FOR(i,n) REP(i,0,int(n)-1)
#define ITER(i,t) for (auto i = t.begin(); i != t.end(); ++i)

#define SZ(x) int((x).size())
#define ALL(x) (x).begin(), (x).end()
#define UNIQUE(x) {sort(ALL(x)); (x).erase(unique(ALL(x)), (x).end());}

#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define MS(X, v) memset((X), (v), sizeof((X)))
//#define DB(v) cerr << #v << " = " << (v) << endl;

typedef pair<int,int> pii;
typedef vector<int> vi;
typedef int64_t ll;
/*}}}*/

const int N = 50000+10;
const int INF = 1000000000;

struct MinTree {
    #define LC(x) ((x)<<1)
    #define RC(x) (((x)<<1)|1)
    int M, s;
    vector<int> sta, tag, val;
    const int _INF = 1000000000;
    void init (int n) { // domain of elements is [1..n], h = ceil(log2(n+2))
        int h = 32 - __builtin_clz(n+1);
        M = (1<<h);
        val.assign(M<<1, 0); // max val
        tag.assign(M<<1, 0); // lazy offset
        sta.assign(h+2, 0); // h+1, h+2 to be save
    }
    void show(){
        #ifdef HOME
        FOR(i,M<<1){ DB(i,tag[i],val[i]); }
        #endif
    }
    inline void _down(int p){
        if(!tag[p] || M<=p) return;
        _set(LC(p), tag[p]), _set(RC(p), tag[p]);
        tag[p] = 0;
    }
    inline void _up(int p){
        //DB("up:",p);
        if(M<=p) return;
        val[p] = max(val[LC(p)], val[RC(p)]);
        //FOR(i, R) el[p][i], el[LC(p)][i], el[RC(p)][i];
    }
    inline void _get(int p, int &r){
        r = max(r, val[p]);
        //ADD(r, el[p][0]);
    }
    inline void _set(int p, int v){
        tag[p] += v, val[p] += v;
    }
    int _ep_down(int p, bool lr) {
        int top = 0;
        //for(; p && ((p&1)^lr); p>>=1);
        for(; p; p>>=1) sta[top++] = p;
        while(top) _down(sta[--top]);
        return sta[0];
    }
    void Set2 (int p, int v){
        // point max
        p += M;
        _ep_down(p, p&1);
        // set el[p+M];
        tag[p] = 0, val[p] = max(val[p], v);
        for (p>>=1; p; p>>=1) _up(p);
    }
    void Set1 (int le, int ri, int v) {
        // range + 1
        int epl = 0, epr = 0; // end points
        for(le+=M-1, ri+=M+1; le^ri^1; le>>=1, ri>>=1) {
            DB(le,ri,epl,epr);
            if (~le&1) {
                if(!epl) _ep_down(epl=(le^1), 0);
                _set(le^1, v);
            }
            if (ri&1) {
                if(!epr) _ep_down(epr=(ri^1), 1);
                _set(ri^1, v);
            }
        }
        for(epl>>=1; epl; epl>>=1) _up(epl);
        for(epr>>=1; epr; epr>>=1) _up(epr);
    }
    int Query (int le, int ri) {
        // range max
        int ret = 0;
        int epl = 0, epr = 0; // end points
        for(le+=M-1, ri+=M+1; le^ri^1; le>>=1, ri>>=1) {
            DB("Query:",le,ri,ret);
            if (~le&1) {
                if(!epl) _ep_down(epl=le^1, 0);
                _get(le^1, ret);
            }
            if (ri&1) {
                if(!epr) _ep_down(epr=ri^1, 1);
                _get(ri^1, ret);
            }
        }
        return ret;
    }
};


struct dat{
    int t,le,ri;
    dat (int t=0, int le=0, int ri=0): t(t), le(le), ri(ri) {}
};

int T, n, m;
dat d[N];
int f[N][2], dp[N];

int ans[N];

int main(){
    R(T);
    FOR(_cnt,T){
        R(m,n);
        FOR(i,n){ char c[5]; R(c); d[i].t = (c[0]=='D'||c[0]=='M'); }
        FOR(i,n) R(d[i].le);
        FOR(i,n) R(d[i].ri);
        //*
        int nn = 0;
        FOR(i,n){
            if(d[i].le>d[i].ri) continue;
            d[nn++] = d[i];
        }
        swap(n,nn);
        // */
        sort(d, d+n, [](const dat a, const dat b){
             if(a.ri!=b.ri) return a.ri<b.ri;
             else return a.le<b.le;
        });
        //FOR(i,n){ DB(d[i].t, d[i].le, d[i].ri); }

        REP(j,0,m) f[j][0] = f[j][1] = 0;
        MinTree tree[2];
        tree[0].init(m), tree[1].init(m);
        FOR(i,n){
            int t=d[i].t, le=d[i].le, ri=d[i].ri;
            int &val = dp[i];
            tree[t^1].Set1(1,le,1);
            val = max(1, tree[t^1].Query(1,le));
            tree[t].Set2(ri, val);
            /*
            // f[j][t^1]++, j=1~le
            // val = max(f[j][t^1]: j=1~le)
            // max(f[ri][t], val)
            REP(j,1,m){
                if(j<=le) val = max(val, ++f[j][t^1]);
                else f[j][t^1] = max(f[j][t^1], f[j-1][t^1]);
                if(ri<=j) f[j][t] = max(f[j][t], val);
            }
            // */
        }


        vector<pii> dpr;
        FOR(i,n) dpr.EB(MP(dp[i],d[i].ri));
        sort(ALL(dpr), [](const pii a, const pii b){ return a.F > b.F; });
        MS(ans, INF);

        int p = 0, mm = INF;
        REPD(i,nn,1){
            for(; p<n && dpr[p].F>=i; ++p)
                mm = min(mm, dpr[p].S);
            ans[i] = mm==INF ? -1 : mm;
        }
        FORI(i,nn) printf("%d ", ans[i]); puts("");
        /*
        FOR(i,n) printf("%d ", dp[i]); puts("");
        //FOR(i,n) printf("%d ", dp2[i][0]); puts("");
        //FOR(i,n) printf("%d ", dp2[i][1]); puts("");
        // */
    }

    return 0;
}

/*

*/