#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits.h>
#include <climits>
#include <map>
#include <unordered_map>
#define _USE_MATH_DEFINES
#include <cmath>
#include <set>
#include <unordered_set>
#include <iterator>
#include <deque>
#include <assert.h>
#include <cstdlib>
#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
ull min(ull x, ull y){ if (x<y) return x; return y;}
ull max(ull x, ull y){ if (x<y) return y; return x;}
ll min(ll x, ll y){ if (x<y) return x; return y;}
ll max(ll x, ll y){ if (x<y) return y; return x;}
double min(double x, double y){ if (x<y) return x; return y;}
double max(double x, double y){ if (x<y) return y; return x;}
// s.lower_bound(val) -> iterator to first element >= val (or s.end() if not present)
// s.upper_bound(val) -> iterator to the first element > val (or s.end() if not present)
ull gcd(ull x, ull y){
    if (!x) return y;
    if (!y) return x;
    if (x>y) swap(x,y);
    return gcd(x, y%x);
}
ull inv(ull a, ull c){ // a,c are coprime and a<c
    if (a==1){
        return 1;
    }
    return ((c-(c/a))*inv(c%a,c))%c;
}
void printv(vector<int> &a){
    int n = a.size();
    for (int i = 0; i < n; ++i){
        cout<<a[i]<<" ";
    }
    cout<<" END\n";
}

int n, m, x[300005] = {0}, ans[300005] = {0}, idx[300005] = {0};
char X[300005];


int comp(int i, int j){
    return x[i]<x[j];
}

void sol(vector<int> &a){

    int N = (int)a.size();
    vector<bool> done(N,0);
    stack<int> st;

    for (int i = 0; i < N; ++i){
        int I = a[i];
        if (X[I] == 'R'){
            st.push(i);
        }
        else if (!st.empty()){
            int time = (x[I] - x[a[st.top()]])/2;
            ans[a[st.top()]] = time;
            ans[I] = time;
            done[i] = 1;
            done[st.top()] = 1;
            st.pop();
        }
    }

    vector<int> l, r;

    for (int i = 0; i < N; ++i){
        if (!done[i]){
            if (X[a[i]] == 'L') l.push_back(a[i]);
            else r.push_back(a[i]);
        }
    }

    int L = (int)l.size(), R = (int)r.size();

    for (int i = 1; i < L; i += 2){
        int time = x[l[i-1]] + (x[l[i]] - x[l[i-1]])/2;
        ans[l[i-1]] = time;
        ans[l[i]] = time;
    }

    for (int i = R - 2; i >= 0; i -= 2){
        int time = m - x[r[i+1]] + (x[r[i+1]] - x[r[i]])/2;
        ans[r[i]] = time;
        ans[r[i+1]] = time;
    }

    if ((L&1) && (R&1)){
        int tmin = min(x[l[L-1]],m-x[r[0]]);
        int tmax = max(x[l[L-1]],m-x[r[0]]);
        int time = (x[r[0]] - x[l[L-1]] + tmin*2)/2 + tmax;
        ans[l[L-1]] = time;
        ans[r[0]] = time;
    }


}

int main(){
    
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);


    int t;

    cin>>t;

    while (t--){
        

        cin>>n>>m;


        for (int i = 0; i < n; ++i){
            cin>>x[i];
            idx[i] = i;
            ans[i] = -1;
        }

        for (int i = 0; i < n; ++i){
            cin>>X[i]; 
        }

        sort(idx, idx + n, comp);

        vector<int> a, b;

        for (int i = 0; i < n; ++i){
            int I = idx[i];
            if (x[I]&1){
                a.push_back(I);
            }
            else{
                b.push_back(I);
            }
        }

        sol(a);
        sol(b);

        for (int i = 0; i < n; ++i){
            cout<<ans[i]<<" ";
        }

        cout<<"\n";


    }
    
    

    return 0;
}


