#include <iostream>
#include <algorithm>
#include <utility>
#include <memory>
#include <limits>
#include <vector>
using namespace std;
// depth = N means that there is 2^N leaf nodes
// int may be changed to another type
// T = current value, U = value pending propagation
template <typename T, typename U>
struct segmenttree_lazy{
    // lazy param of node x has not been applied to node x and all nodes below it
    unsigned Depth;
    unique_ptr<pair<T,U>[]> arr;
    segmenttree_lazy(unsigned depth):Depth(depth),arr(make_unique<pair<T,U>[]>(1<<(depth+1))){}
    T effective_value(size_t index, size_t, size_t){
        return arr[index].first+arr[index].second; // combiner for lazy value with real value
    }
    void propagate(size_t index, size_t rb, size_t re){
        auto prop_val=arr[index].second; // propagation function...
        arr[index].first=effective_value(index,rb,re);
        arr[index].second=0;
        arr[index<<1].second+=prop_val;
        arr[(index<<1)+1].second+=prop_val;
    }
    void update(size_t index, size_t rb, size_t re, size_t ib, size_t ie, unsigned val){
        if(rb==ib&&re==ie){
            arr[index].second+=val; // update lazy storage
            return;
        }
        //propagate(index,rb,re); // no need
        size_t rm=(rb+re)>>1;
        if(ib<rm)update(index<<1,rb,rm,ib,min(rm,ie),val); // transformation for children
        if(rm<ie)update((index<<1)+1,rm,re,max(ib,rm),ie,val); // transformation for children
        arr[index].first=max(effective_value(index<<1,rb,rm),effective_value((index<<1)+1,rm,re)); // coalesce function
    }
    void update(size_t indexbegin, size_t indexend, unsigned val){
        update(1,0,1<<Depth,indexbegin,indexend,val);
    }
    // past-the-end
    unsigned query(size_t index, size_t rb, size_t re, size_t ib, size_t ie){
        if(rb==ib&&re==ie){
            return effective_value(index,rb,re);
        }
        propagate(index,rb,re);
        unsigned ret=0; // additive identity
        size_t rm=(rb+re)>>1;
        if(ib<rm)ret=max(ret,query(index<<1,rb,rm,ib,min(rm,ie))); // coalesce function
        if(rm<ie)ret=max(ret,query((index<<1)+1,rm,re,max(ib,rm),ie)); // coalesce function
        return ret;
    }
    // past-the-end
    unsigned query(size_t indexbegin, size_t indexend){
        return query(1,0,1<<Depth,indexbegin,indexend);
    }
};
int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    unsigned t;
    cin>>t;
    while(t-->0){
        unsigned n,m;
        cin>>m>>n;
        unique_ptr<vector<unsigned>[]> ecboard = make_unique<vector<unsigned>[]>(m);
        unique_ptr<vector<unsigned>[]> dmboard = make_unique<vector<unsigned>[]>(m);
        {
            unique_ptr<char[]> tarr = make_unique<char[]>(n);
            unique_ptr<unsigned[]> sarr = make_unique<unsigned[]>(n);
            unique_ptr<unsigned[]> darr = make_unique<unsigned[]>(n);
            for(unsigned i=0;i<n;++i)cin>>tarr[i];
            for(unsigned i=0;i<n;++i)cin>>sarr[i];
            for(unsigned i=0;i<n;++i)cin>>darr[i];
            for(unsigned i=0;i<n;++i){
                if(sarr[i]<darr[i]){
                    --sarr[i];--darr[i];
                    if(tarr[i]=='E'||tarr[i]=='C'){
                        ecboard[darr[i]].emplace_back(sarr[i]);
                    }
                    else{
                        dmboard[darr[i]].emplace_back(sarr[i]);
                    }
                }
            }
        }
        unique_ptr<unsigned[]> best_vals = make_unique<unsigned[]>(m);
        {
            segmenttree_lazy<unsigned,unsigned> ecdp(16), dmdp(16);
            //unique_ptr<unsigned[]> ecdp = make_unique<unsigned[]>(m);
            //unique_ptr<unsigned[]> dmdp = make_unique<unsigned[]>(m);
            //multiset<unsigned, greater<unsigned>> ecmax, ecmin;
            for(unsigned i=0;i<m;++i){
                for(unsigned ecstart : ecboard[i]){
                    ecdp.update(0,ecstart+1,1);
                }
                for(unsigned dmstart : dmboard[i]){
                    dmdp.update(0,dmstart+1,1);
                }
                unsigned ec_best=ecdp.query(0,i);
                unsigned dm_best=dmdp.query(0,i);
                ecdp.update(i,i+1,dm_best);
                dmdp.update(i,i+1,ec_best);
                best_vals[i] = max(ec_best,dm_best);
            }
        }
        unsigned curr_zoo=0;
        for(unsigned i=1;i<=n;++i){
            while(curr_zoo<m&&best_vals[curr_zoo]<i){
                ++curr_zoo;
            }
            if(curr_zoo<m){
                cout<<curr_zoo+1<<' ';
            }
            else{
                cout<<"-1 ";
            }
        }
        cout<<endl;
    }
}