#include <bits/stdc++.h>
using namespace std;
#define FOR(i, j, k, in) for (int i=j ; i<k ; i+=in)
#define RFOR(i, j, k, in) for (int i=j ; i>=k ; i-=in)
#define REP(i, j) FOR(i, 0, j, 1)
#define RREP(i, j) RFOR(i, j, 0, 1)
#define all(cont) cont.begin(), cont.end()
#define INF (int)1e9
#define EPS 1e-6
#define SWAP(t,x,y) t tmp; tmp = (x); (x) = (y); (y) = tmp;
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define MP make_pair
#define PB push_back
#define MEM(a, b) memset(a, (b), sizeof(a))
typedef long long int lli;
typedef pair<lli, lli> pll;
typedef pair<int, int> pii;
typedef unordered_map<char, lli> mcl;
typedef unordered_map<lli, lli> mll;
typedef unordered_set<lli> usl;
typedef unordered_set<char> usc;
typedef unordered_set<pll> uspll;
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<pii> vii;
typedef vector<pll> vpll;
typedef map<int,int> mpii;
typedef set<int> si;
typedef multiset<int> msi;
typedef pair<double, double> pdd;
const double pi = 3.14159265358979323;
lli n, k, m, tc, ans = 0, count = 0, mymax = -1e18, mymin = 1e18, x, y;
string final_ans = "";
string s = "";
 
vector<pair<int, int>> directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

template <typename T> 
ostream& operator<<(ostream& os, const vector<T>& v) 
{  
    REP(i, v.size())
        os << v[i] << " ";
	os << '\n';
    return os; 
}
map<int, int> answers;
void fill_map(vector<pair<pair<int, int>, char>>& pos, int m){
	vector<int> right_stack;
	vector<int> left_stack;
	REP(j, pos.size()) {
		if(pos[j].second == 'R') right_stack.PB(j);
		else{
			if(right_stack.size() != 0){
				int r_idx = right_stack[right_stack.size() - 1]; right_stack.pop_back();
				int r_value = pos[r_idx].first.first;
				int l_value = pos[j].first.first;
				int ans = (l_value - r_value) / 2;
				answers[pos[r_idx].first.second] = ans;
				answers[pos[j].first.second] = ans;
			}
			else left_stack.PB(j);
		}
	}
	//now, we have a bunch of Ls followed by a bunch of Rs... how to match? Match Ls together starting from front, match Rs starting from back
	for(int i = 0; i + 1 < left_stack.size(); i += 2){
		int x = pos[left_stack[i]].first.first;
		int y = pos[left_stack[i + 1]].first.first;
		answers[pos[left_stack[i]].first.second] = (x + y) / 2;
		answers[pos[left_stack[i + 1]].first.second] = (x + y) / 2;
	}
	if(right_stack.size() == 0) return;
	for(int i = right_stack.size() - 1; i >= 1; i -= 2){
		int x = pos[right_stack[i]].first.first;
		int y = pos[right_stack[i - 1]].first.first;
		answers[pos[right_stack[i]].first.second] = m - (x + y) / 2;
		answers[pos[right_stack[i - 1]].first.second] = m - (x + y) / 2;
	}
	if((left_stack.size() % 2) && (right_stack.size() % 2)){
		//Combine left_stack[last] and right_stack[0]
		int x = pos[right_stack[0]].first.first;
		int y = pos[left_stack[left_stack.size() - 1]].first.first;
		int ans = (2 * m - (x - y)) / 2;
		answers[pos[right_stack[0]].first.second] = ans;
		answers[pos[left_stack[left_stack.size() - 1]].first.second] = ans;
	}
}
int main(){
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> tc;
	REP(i, tc){
		answers.clear();
		cin >> n >> m;
		vector<char> directions(n);
		vector<int> positions(n);
		REP(j, n) cin >> positions[j];
		REP(j, n) cin >> directions[j];
		vector<pair<pair<int, int>, char>> odd_pos;
		vector<pair<pair<int, int>, char>> even_pos;
		REP(j, n){
			if(positions[j] % 2) odd_pos.PB({{positions[j], j}, directions[j]});
			else even_pos.PB({{positions[j], j}, directions[j]});
		}
		sort(all(odd_pos));
		sort(all(even_pos));
		fill_map(even_pos, m);
		fill_map(odd_pos, m);
		vector<int> myans;
		REP(j, n){
			if(answers.find(j) == answers.end()) myans.PB(-1);
			else myans.PB(answers[j]);
		}
		cout << myans;	
	}
}