#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
//#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using ll = long long;
using ld = long double;
using pii = pair<int,int>;
using vi = vector<int>;
using vd = vector<double>;
using vll = vector<ll>;
using vs = vector<string>;
#define range(i,a,b) for(auto i=(a);i<(b);i++)
#define rep(i,n) range(i,0,n)
#define all(c) begin(c),end(c)
#define CLR(i,x) memset(i,x,sizeof(i))
#define clr0(i) CLR(i,0)
#define clr1(i) CLR(i,-1)
#define bit(x,i) ((x>>i)&1)
#define M(x) ((x)%MOD)
#define acc(f,x,y) x=f(x,y)
#define fst first
#define snd second
#define tup make_tuple

template <int N>
struct Tree {

struct Node {
Node *l, *r;
int a, b, ans, delta;

void push() {
	l->delta += delta;
	r->delta += delta;
	delta = 0;
}

void collect() {
	ans = max(l->get(), r->get());
}

inline int get() {
	return ans + delta;
}
};

Node p0[2 * N];

Node * init(int i, int j, Node *p = nullptr) {
	if (!p) p = p0;
	p->a = i, p->b = j, p->l = p->r = nullptr;
	p->ans = p->delta = 0;
	if (j - i == 1) {
		return p + 1;
	}
	int k = (i + j) / 2;
	return init(k, j, p->r = init(i, k, p->l = p + 1));
}

void incr(int i, int j, Node *p = nullptr) {
	if (!p) p = p0;
	if (j <= p->a || p->b <= i) return;
	if (i <= p->a && p->b <= j) {
		p->delta++;
		return;
	}
	p->push();

	incr(i, j, p->l);
	incr(i, j, p->r);

	p->collect();
}

int query(int i, int j, Node *p = nullptr) {
	if (!p) p = p0;
	if (j <= p->a || p->b <= i) return 0;
	if (i <= p->a && p->b <= j) {
		return p->get();
	}
	p->push();

	int ans = max(query(i, j, p->l), query(i, j, p->r));

	p->collect();
	return ans;
}

void set(int i, int v, Node *p = nullptr) {
	if (!p) p = p0;
	if (i < p->a || p->b <= i) return;
	if (p->a == i && p->b == i + 1) {
		assert(p->delta == 0);
		p->ans = v;
		return;
	}
	p->push();

	set(i, v, p->l);
	set(i, v, p->r);

	p->collect();
}
};

struct Iv {
bool t;
int a, b;

inline bool operator<(const Iv & o) const {
	if (t != o.t) return t < o.t;
	if (b != o.b) return b < o.b;
	if (a != o.a) return a < o.a;
	return false;
}
};

constexpr int N = 50005;

char buf[5];
Iv xs[N];

Tree<N> tree[2];

void work() {
	int m, k;
	scanf("%d%d", &m, &k);
	tree[0].init(0, m + 1);
	tree[1].init(0, m + 1);

	rep (i, k) {
		scanf("%s", buf);
		xs[i].t = buf[0] == 'E' || buf[0] == 'C';
	}
	rep (i, k) scanf("%d", &xs[i].a);
	rep (i, k) scanf("%d", &xs[i].b);

	int j = 0;
	rep (i, k) if (xs[i].a < xs[i].b) xs[j++] = xs[i];
	int n = j;

	sort(xs, xs + n);

	Iv *x0 = xs, *x1 = xs;
	while (x1 < xs + n && !x1->t) x1++;

	j = 0;
	Iv *y0 = x1, *y1 = xs + n;
	rep (i, m + 1) {
		for (; x0 < x1 && x0->b == i; x0++) {
			tree[0].incr(0, x0->a + 1);
		}
		for (; y0 < y1 && y0->b == i; y0++) {
			tree[1].incr(0, y0->a + 1);
		}
		int best0 = tree[0].query(0, i);
		int best1 = tree[1].query(0, i);
		tree[1].set(i, best0);
		tree[0].set(i, best1);
		int best = max(best0, best1);
		for (; j < best; j++) {
			printf("%d ", i);
		}
	}
	for (; j < k; j++) printf("-1 ");
	printf("\n");
}

int main() {
	int t;
	scanf("%d", &t);
	while (t--) work();
	return 0;
}