#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <cstring>
#include <utility>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <queue>
#include <stack>
#include <set>
#include <map>
using namespace std;

#define LL   long long
#define ld   long double
#define pii  pair<int,int>
#define pLL  pair<LL,LL>
#define vint vector<int>
#define vLL  vector<LL>
#define vpii vector<pii>

#define SZ(x) ((int)(x).size())
#define ALL(x) (x).begin(),(x).end()
#define F first
#define S second
#define MP make_pair
#define PB push_back

#define Si(x) scanf("%d",&(x));
#define Sii(x,y) scanf("%d %d",&(x),&(y));
#define Siii(x,y,z) scanf("%d %d %d",&(x),&(y),&(z));
#define Siiii(x,y,z,w) scanf("%d %d %d %d",&(x),&(y),&(z),&(w));
#define Siiiii(x,y,z,w,a) scanf("%d %d %d %d %d",&(x),&(y),&(z),&(w),&(a));
#define Siiiiii(x,y,z,w,a,b) scanf("%d %d %d %d %d %d",&(x),&(y),&(z),&(w),&(a),&(b));
#define SL(x) scanf("%lld",&(x));
#define SLL(x,y) scanf("%lld %lld",&(x),&(y));
#define SLLL(x,y,z) scanf("%lld %lld %lld",&(x),&(y),&(z));
#define SLLLL(x,y,z,w) scanf("%lld %lld %lld %lld",&(x),&(y),&(z),&(w));
#define SLLLLL(x,y,z,w,a) scanf("%lld %lld %lld %lld %lld",&(x),&(y),&(z),&(w),&(a));
#define SLLLLLL(x,y,z,w,a,b) scanf("%lld %lld %lld %lld %lld %lld",&(x),&(y),&(z),&(w),&(a),&(b));

#define Pi(x) printf("%d\n",(x));
#define Pii(x,y) printf("%d %d\n",(x),(y));
#define Piii(x,y,z) printf("%d %d %d\n",(x),(y),(z));
#define Piiii(x,y,z,w) printf("%d %d %d %d\n",(x),(y),(z),(w));
#define Piiiii(a,b,c,d,e) printf("%d %d %d %d %d\n",(a),(b),(c),(d),(e));
#define Piiiiii(a,b,c,d,e,f) printf("%d %d %d %d %d %d\n",(a),(b),(c),(d),(e),(f));
#define PL(x) printf("%lld\n",(x)*1LL);
#define PLL(x,y) printf("%lld %lld\n",(x)*1LL,(y)*1LL);
#define PLLL(x,y,z) printf("%lld %lld %lld\n",(x)*1LL,(y)*1LL,(z)*1LL);
#define PLLLL(x,y,z,w) printf("%lld %lld %lld %lld\n",(x)*1LL,(y)*1LL,(z)*1LL,(w)*1LL);
#define PLLLLL(a,b,c,d,e) printf("%lld %lld %lld %lld %lld\n",(a),(b),(c),(d),(e));
#define PLLLLLL(a,b,c,d,e,f) printf("%lld %lld %lld %lld %lld %lld\n",(a),(b),(c),(d),(e),(f));

#define Pi1(x) printf("%d",  (x));
#define PL1(x) printf("%lld",(x));
#define Pspace putchar(' ');
#define Pendl  puts("");

#define MEM0(x) memset( (x), 0, sizeof( (x) ) )
#define MEM1(x) memset( (x),-1, sizeof( (x) ) )
#define REP1(i,n)  for (int i = 1; (n) >= i ; ++i)
#define REP0(i,n)  for (int i = 0; (n) >  i ; ++i)

int myRnd() {
    return abs(  ((rand()<<15) | rand()) );
}

int myRnd(int L,int R) {
    return abs(( (rand()<<15)|rand() ) ) % (R-L+1) + L;
}

void Parr(int *arr,int L,int R) {
    for (int i=L;R>=i;i++) {
        printf("%d%c",arr[i]," \n"[i==R]);
    }
}

void Pvec(vint v) {
    for (int i=0;SZ(v)>i;i++) {
        printf("%d%c",v[i]," \n"[i==SZ(v)-1]);
    }
}

void Sarr(int *arr,int L,int R) {
    for (int i=L;R>=i;i++)
    {
        Si(arr[i]);
    }
}

struct Node{
    Node *lc,*rc;
    int mx,tag;
    Node()
    {
        lc=rc=NULL;
        mx = tag = 0;
    }
    void pull()
    {
        mx = max(lc->mx,rc->mx);
    }
};

Node* Build(int L,int R)
{
    Node* node =new Node();
    if (L==R) return node;
    int mid=(L+R)>>1;
    node->lc=Build(L,mid);
    node->rc=Build(mid+1,R);
    return node;
}

void push(Node* node,int L,int R)
{
    if (L==R) node->tag = 0;
    if (node->tag == 0) return;
    node->lc->tag += node->tag;
    node->lc->mx  += node->tag;
    node->rc->tag += node->tag;
    node->rc->mx  += node->tag;
    node->tag = 0;
    return;
}

void modify(Node* node,int L,int R,int l,int r,int val)
{
    if (L>r || l>R) return;
    else if (l<=L && R<=r) {
        node->mx += val;
        node->tag += val;
        return;
    }
    push(node,L,R);
    int mid=(L+R)>>1;
    modify(node->lc,L,mid,l,r,val);
    modify(node->rc,mid+1,R,l,r,val);
    node->pull();
    return;
}

int query(Node* node,int L,int R,int l,int r)
{
    if (l>R || L>r) return 0;
    else if (l<=L && R<=r) return node->mx;
    push(node,L,R);
    int mid=(L+R)>>1;
    return max( query(node->lc,L,mid,l,r),query(node->rc,mid+1,R,l,r) );
}

const int N = 50006;

struct Animal
{
    int type;
    int l,r;
    Animal(){}
    Animal(int _type,int _l,int _r)
    {
        type = _type;
        l=_l;
        r=_r;
    }
    bool operator<(const Animal &m2)
    {
        return l < m2.r || l==m2.l && r < m2.r;
    }
};

char c[N];
int s[N],d[N];

int cc(char c)
{
    if (c=='C' || c=='E') return 0;
    else return 1;
}

int dp[N];
int ans[N];

vpii dd[N];

Node* root[2];

int main () {
    srand(time(NULL));
    int T;
    Si(T);
    while (T--)
    {
        int m,n;
        Sii(m,n);
        REP1(i,m)
        {
            dd[i].clear();
        }
        MEM0(dp);
        REP1(i,n)
        {
            cin >> c[i];
        }
        REP1(i,n)
        {
            Si(s[i]);
        }
        REP1(i,n)
        {
            Si(d[i]);
            if (s[i] < d[i])dd[ d[i] ].PB({cc(c[i]),s[i]});
        }
        root[0]=Build(1,m);
        root[1]=Build(1,m);
        MEM1(ans);
        REP1(i,m)
        {
            dp[i] = dp[i-1];
            for (pii p:dd[i])
            {
                modify(root[ p.F ],1,m,1,p.S,1);
            }
            dp[i] = max( query(root[0],1,m,1,i),query(root[1],1,m,1,i) );
            modify(root[0],1,m,i,i,dp[i]);
            modify(root[1],1,m,i,i,dp[i]);
            if (ans[ dp[i] ] == -1) ans[ dp[i] ] = i;
        }
        for (int i=n;i>=1;i--)
        {
            if (ans[i+1] != -1 &&ans[i] == -1) ans[i] = ans[i+1];
        }
        Parr(ans,1,n);
    }
}