#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define fr first
#define se second
int arr[100005];
int brr[100005];
int crr[100005];
vector < pair<int,int>  > v[100005];
int tree1[100005*4];
int tree2[100005*4];
int lazy1[4*100005];
int lazy2[4*100005];
int answ[100005];
void updateRange1(int node, int start, int end, int l, int r, int val)
{
    if(lazy1[node] != 0)
    { 
        // This node needs to be updated
        tree1[node] +=  lazy1[node];    // Update it
        if(start != end)
        {
            lazy1[node*2] += lazy1[node];                  // Mark child as lazy
            lazy1[node*2+1] += lazy1[node];                // Mark child as lazy
        }
        lazy1[node] = 0;                                  // Reset it
    }
    if(start > end or start > r or end < l)              // Current segment is not within range [l, r]
        return;
    if(start >= l and end <= r)
    {
        // Segment is fully within range
        tree1[node] += val;
        if(start != end)
        {
            // Not leaf node
            lazy1[node*2] += val;
            lazy1[node*2+1] += val;
        }
        return;
    }
    int mid = (start + end) / 2;
    updateRange1(node*2, start, mid, l, r, val);        // Updating left child
    updateRange1(node*2 + 1, mid + 1, end, l, r, val);   // Updating right child
    tree1[node] = max(tree1[node*2] ,tree1[node*2+1]);        // Updating root with max value 
}

int queryRange1(int node, int start, int end, int l, int r)
{
    if(start > end or start > r or end < l)
        return 0;         // Out of range
    if(lazy1[node] != 0)
    {
        // This node needs to be updated
        tree1[node] +=  lazy1[node];            // Update it
        if(start != end)
        {
            lazy1[node*2] += lazy1[node];         // Mark child as lazy
            lazy1[node*2+1] += lazy1[node];    // Mark child as lazy
        }
        lazy1[node] = 0;                 // Reset it
    }
    if(start >= l and end <= r)             // Current segment is totally within range [l, r]
        return tree1[node];
    int mid = (start + end) / 2;
    int p1 = queryRange1(node*2, start, mid, l, r);         // Query left child
    int p2 = queryRange1(node*2 + 1, mid + 1, end, l, r); // Query right child
    return max(p1 , p2);
}
void updateRange2(int node, int start, int end, int l, int r, int val)
{
    if(lazy2[node] != 0)
    { 
        // This node needs to be updated
        tree2[node] +=  lazy2[node];    // Update it
        if(start != end)
        {
            lazy2[node*2] += lazy2[node];                  // Mark child as lazy
            lazy2[node*2+1] += lazy2[node];                // Mark child as lazy
        }
        lazy2[node] = 0;                                  // Reset it
    }
    if(start > end or start > r or end < l)              // Current segment is not within range [l, r]
        return;
    if(start >= l and end <= r)
    {
        // Segment is fully within range
        tree2[node] += val;
        if(start != end)
        {
            // Not leaf node
            lazy2[node*2] += val;
            lazy2[node*2+1] += val;
        }
        return;
    }
    int mid = (start + end) / 2;
    updateRange2(node*2, start, mid, l, r, val);        // Updating left child
    updateRange2(node*2 + 1, mid + 1, end, l, r, val);   // Updating right child
    tree2[node] = max(tree2[node*2] ,tree2[node*2+1]);        // Updating root with max value 
}

int queryRange2(int node, int start, int end, int l, int r)
{
    if(start > end or start > r or end < l)
        return 0;         // Out of range
    if(lazy2[node] != 0)
    {
        // This node needs to be updated
        tree2[node] +=  lazy1[node];            // Update it
        if(start != end)
        {
            lazy2[node*2] += lazy2[node];         // Mark child as lazy
            lazy2[node*2+1] += lazy2[node];    // Mark child as lazy
        }
        lazy2[node] = 0;                 // Reset it
    }
    if(start >= l and end <= r)             // Current segment is totally within range [l, r]
        return tree2[node];
    int mid = (start + end) / 2;
    int p1 = queryRange2(node*2, start, mid, l, r);         // Query left child
    int p2 = queryRange2(node*2 + 1, mid + 1, end, l, r); // Query right child
    return max(p1 , p2);
}
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		memset(tree1,0,sizeof(tree1));
		memset(tree2,0,sizeof(tree2));
		memset(lazy1,0,sizeof(lazy1));
		memset(lazy2,0,sizeof(lazy2));
		int m,n;
		scanf("%d %d",&m,&n);
		int i,j;
		for(i=0;i<=m;i++)
		v[i].clear();
		for(i=0;i<n;i++)
		{
			string str;
			cin>>str;
			if(str=="E"||str=="C")
			arr[i]=1;
			else
			arr[i]=2;
		}
		for(i=0;i<n;i++)
		scanf("%d",&brr[i]);
		for(i=0;i<n;i++)
		scanf("%d",&crr[i]);
		for(i=0;i<n;i++)
		v[crr[i]].pb(mp(arr[i],brr[i]));
		for(i=1;i<=n+2;i++)
		answ[i]=1e9;
		for(i=1;i<=m;i++)
		{
			for(j=0;j<v[i].size();j++)
			{
				int x=v[i][j].se;
				int type=v[i][j].fr;
				if(x>=i)
				continue;
				if(type==1)
				updateRange1(1,1,m,1,x,1);
				else
				updateRange2(1,1,m,1,x,1);
			}
			int xx,yy;
			xx=queryRange1(1,1,m,1,i-1);
			yy=queryRange2(1,1,m,1,i-1);
			answ[max(xx,yy)]=min(answ[max(xx,yy)],i);
			updateRange1(1,1,m,i,i,max(xx,yy));
			updateRange2(1,1,m,i,i,max(xx,yy));
		}
		for(i=n;i>=1;i--)
		answ[i]=min(answ[i],answ[i+1]);
		for(i=1;i<=n;i++)
		{
			if(answ[i]==(1e9))
			printf("-1 ");
			else
			printf("%d ",answ[i]);
		}
		printf("\n");
	}
}