import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

public class Solution {
	
	static int N, M;
	static int[] max;
	static List<Integer>[][] adj;
	
	static void solve() {
		int before = 0;
		
		Lazy elephantos = new Lazy(N);
		Lazy doggos = new Lazy(N);
		
		for (int i = 0; i < N; i++) {
			max[i] = before;
			// take the elephant and cat
			int mem = 0;
			for (int j : adj[i][0]) 
				max[i] = Math.max(max[i], max[j] + ++mem + elephantos.sum(1, 0, N - 1, j, i - 1));
			
			for (int j : adj[i][0])
				elephantos.increment(1, 0, N - 1, j);
			
			// take the dog and mouse
			mem = 0;
			for (int j : adj[i][1]) 
				max[i] = Math.max(max[i], max[j] + ++mem + doggos.sum(1, 0, N - 1, j + 1, i - 1));
			
			for (int j : adj[i][1]) 
				doggos.increment(1, 0, N - 1, j);
			
			before = Math.max(max[i], before);
		}
	}
	
	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int T = input.nextInt();
		
		for (int t = 0; t < T; t++) {
			N = input.nextInt();
			M = input.nextInt();
			max = new int[N];
			adj = new LinkedList[N][2];
			for (int i = 0; i < N; i++) 
				adj[i] = new LinkedList[] {new LinkedList<Integer>(), new LinkedList<Integer>()};
			
			int[] id = new int[M];
			int[] source = new int[M];
			int[] sink = new int[M];
			
			for (int i = 0; i < M; i++) 
				id[i] = id(input.next());
			for (int i = 0; i < M; i++) 
				source[i] = input.nextInt() - 1;
			for (int i = 0; i < M; i++) 
				sink[i] = input.nextInt() - 1;
			
			for (int i = 0; i < M; i++) 
				adj[sink[i]][id[i]].add(source[i]);
			
			for (int i = 0; i < N; i++)
				for (List<Integer> ls : adj[i])
					Collections.sort(ls, Collections.reverseOrder());
			
			solve();
			
			int[] ans = new int[M + 1];
			Arrays.fill(ans, -1);
			for (int i = N - 1; i >= 0; i--)
				ans[max[i]] = i;
			int min = -1;
			for (int i = M; i >= 0; i--) {
				if (min != -1)
					if (ans[i] == -1 || ans[i] > min)
						ans[i] = min;
				if (min == -1 || ans[i] < min)
					min = ans[i];
			}
			
			for (int i = 1; i <= M; i++) {
				if (ans[i] == -1)
					System.out.print(ans[i]);
				else
					System.out.print(ans[i] + 1);
				if (i == M)
					System.out.println();
				else
					System.out.print(" ");
			}
		}
	}
	
	static int id(String s) {
		if (s.equals("E") || s.equals("C"))
			return 0;
		return 1;
	}
}


class Lazy {
	int[] tree;
	
	Lazy(int n) {
		tree = new int[4 * n];
	}
	
	int sum(int i, int l, int r, int a, int b) {
		int sum = 0;
		
		if (tree[i] == 0)
			return 0;
		
		if (r < l || l > b || r < a) 
			return 0;
		
		if (l >= a && r <= b) 
			return tree[i];
		
		
		int mid = (l + r) / 2;
		sum += sum(2 * i, l, mid, a, b);
		sum += sum(2 * i + 1, mid + 1, r, a, b);
		
		return sum;
	}
	
	void increment(int i, int l, int r, int a) {
		
		if (r < l || l > a || r < a)
			return;
		
		if (l == r && l == a) {
			tree[i]++;
			return;
		}
		
		int mid = (l + r) / 2;
		if (mid >= a)
			increment(2 * i, l, mid, a);
		else
			increment(2 * i + 1, mid + 1, r, a);
		
		tree[i]++;
	}
}