#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <ctype.h>
#include <deque>
#include <cstring>
#include <set>
#include <bitset>
#include <map>
#include <chrono>
#include <random>
#include <unordered_map>
#include <stdio.h>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef std::vector<int> vi;
typedef std::vector<bool> vb;
typedef std::vector<string> vs;
typedef std::vector<double> vd;
typedef std::vector<long long> vll;
typedef std::vector<std::vector<int> > vvi;
typedef vector<vll> vvll;
typedef std::vector<std::pair<int, int> > vpi;
typedef vector<vpi> vvpi;
typedef std::pair<int, int> pi;
typedef std::pair<ll, ll> pll;
typedef std::vector<pll> vpll;

const long long mod = 1000000007;
const unsigned gen_seed = std::chrono::system_clock::now().time_since_epoch().count();
std::mt19937_64 gen(gen_seed);

#define all(c) (c).begin(),(c).end()
#define forn(i, a, b) for(int i = a; i < b; i++)
#define read(x) scanf("%d", &x)
#define readv(x, n) vi x(n); forn(i,0,n) scanf("%d", &x[i])

#define pb push_back
#define mp make_pair

class stree {
public:
    int s;
    vi t;
    vi lazy;
    void build (vi & a, int v, int tl, int tr) {
        if(v==1) {
            s = a.size();
            t = vi(4*s, 0);
            lazy = vi(4*s, 0);
        }
        if (tl == tr) {
            t[v] = a[tl];
            lazy[v] = 0;
        }
        else {
            int tm = (tl + tr) / 2;
            build (a, v*2, tl, tm);
            build (a, v*2+1, tm+1, tr);
            lazy[v] = 0;
            t[v] = max(t[v*2], t[v*2 + 1]);
        }
    }
    
    void push(int v) {
        if (lazy[v] == 0) return;
        t[v] += lazy[v];
        if(v<2*s) {
            lazy[v*2] += lazy[v];
            lazy[v*2 + 1] += lazy[v];
        }
        lazy[v] = 0;
    }
    
    void update (int v, int tl, int tr, int l, int r, int add) {
        push(v);
        if (l > r)
            return;
        if (l == tl && tr == r) {
            lazy[v] += add;
            push(v);
        }
        else {
            int tm = (tl + tr) / 2;
            update (v*2, tl, tm, l, min(r,tm), add);
            update (v*2+1, tm+1, tr, max(l,tm+1), r, add);
            t[v] = max(t[v*2], t[v*2 + 1]);
        }
    }
    
    void set (int v, int tl, int tr, int pos, int val) {
        push(v);
        if (pos > tr || pos < tl)
            return;
        if (pos == tl && tr == pos) {
            t[v] = max(t[v],val);
        }
        else {
            int tm = (tl + tr) / 2;
            set (v*2, tl, tm, pos, val);
            set (v*2+1, tm+1, tr, pos, val);
            t[v] = max(t[v*2], t[v*2 + 1]);
        }
    }
    
    int getmax (int v, int tl, int tr, int l, int r) {
        push(v);
        if (l > r)
            return 0;
        if (l == tl && tr == r) {
            return t[v];
        }
        else {
            int tm = (tl + tr) / 2;
            int ret = max(getmax(v*2, tl, tm, l, min(r,tm)),
                         getmax(v*2+1, tm+1, tr, max(l,tm+1), r));
            t[v] = max(t[v*2], t[v*2 + 1]);
            return ret;
        }
    }
};

int main()
{

    int tafa;
    scanf("%d", &tafa);
    forn(agag,0,tafa) {
        int n,m;
        scanf("%d %d\n", &m, &n);
        stree ec,dm;
        vi a(m,0);
        ec.build(a, 1, 0, m-1);
        dm.build(a, 1, 0, m-1);
        vvi pec(m);
        vvi pdm(m);
        vector<char> t(n);
        forn(i,0,n) {
            scanf("%c", &t[i]);
            if(i<n-1) scanf(" ");
        }
        readv(s,n);
        readv(d,n);
        forn(i,0,n) s[i]--,d[i]--;
        forn(i,0,n) {
            if(t[i] == 'E' || t[i] == 'C') {
                if(s[i] < d[i]) pec[d[i]].pb(s[i]);
            }
            else if(t[i] == 'D' || t[i] == 'M') {
                if(s[i] < d[i]) pdm[d[i]].pb(s[i]);
            }
        }
        vi amax(m,0);
        vi dmmax(m,0), ecmax(m,0);
        amax[0] = 0;
        forn(i,1,m) {
            sort(all(pec[i]));
            sort(all(pdm[i]));
            reverse(all(pec[i]));
            reverse(all(pdm[i]));
            forn(j,0,pec[i].size()) {
                int fr = pec[i][j];
                ec.update(1, 0, m-1, 0, fr, 1);
            }
            forn(j,0,pdm[i].size()) {
                int fr = pdm[i][j];
                dm.update(1, 0, m-1, 0, fr, 1);
            }
            amax[i] = max(dm.getmax(1, 0, m-1, 0, m-1), ec.getmax(1, 0, m-1, 0, m-1));
            dm.set(1, 0, m-1, i, amax[i]);
            ec.set(1, 0, m-1, i, amax[i]);
        }
        vi ans(n+1,-1);
        int cur = 1;
        forn(i,0,m) {
            while(amax[i] >= cur) ans[cur++] = i + 1;
        }
        forn(i,1,n+1) printf("%d ", ans[i]);
        printf("\n");
        
    }
    
}