#include <bits/stdc++.h>

using namespace std;
struct Range {
    int l, r;
    bool col;
};
class SegmentTree {
    int tree[200000];
    int sum(int x, int y) {
        return x+y;
    }
    public: 
    SegmentTree() {
        memset(tree, 0, sizeof tree);
    }
    int getMax(int node, int l, int r, int x, int y) {
        if(x ==l && r == y) 
            return tree[node];
        int m = (l+r)/2;
        if(x>m) return getMax(node*2+2, m+1, r, x, y);
        if(y<=m) return getMax(node*2+1, l, m, x, y);
        return max(getMax(node*2+2, m+1, r, m+1, y), getMax(node*2+1, l, m, x, m));
    }
    int getSum(int node, int l, int r, int x, int y) {
        if(x ==l && r == y) 
            return tree[node];
        int m = (l+r)/2;
        if(x>m) return getSum(node*2+2, m+1, r, x, y);
        if(y<=m) return getSum(node*2+1, l, m, x, y);
        return sum(getSum(node*2+2, m+1, r, m+1, y), getSum(node*2+1, l, m, x, m));
    }
    void updateMax(int node, int l, int r, int x, int val) {
        if(l==r) {
            tree[node] = max(tree[node], val);
            return ;
        }
        int m = (l+r)/2;
        if(x>m) updateMax(node*2+2, m+1, r, x, val);
        else updateMax(node*2+1, l, m, x, val);
        tree[node] = max(tree[node*2+2], tree[node*2+1]);
    }
    void updateSum(int node, int l, int r, int x, int val) {
        if(l==r) {
            tree[node] = sum(tree[node], val);
            return ;
        }
        int m = (l+r)/2;
        if(x>m) updateSum(node*2+2, m+1, r, x, val);
        else updateSum(node*2+1, l, m, x, val);
        tree[node] = sum(tree[node*2+2], tree[node*2+1]);
    }
};
bool cmp(const Range& a, const Range& b) {
    if(a.r==b.r) return a.l < b.l;
    return a.r < b.r;
}
vector <int> minimumZooNumbers(int m, int n, vector <char> t, vector <int> s, vector <int> d) {
    int MAXVAL = m+1;
    vector<Range> a;
    vector<int> dp(n), ans;
    for(int i=0;i<n;i++) {
        Range tmp;
        tmp.l = s[i];
        tmp.r = d[i];
        tmp.col = (t[i]=='D'||t[i]=='m');
        a.push_back(tmp);
    }
    sort(a.begin(), a.end(), cmp);
    SegmentTree mxTree[2], sumTree[2];
    for(int i=0;i<n;i++) {
        sumTree[a[i].col].updateSum(0, 0, MAXVAL, a[i].l, 1);
        int t = sumTree[a[i].col].getSum(0, 0, MAXVAL, a[i].l, a[i].r);
        int s = mxTree[a[i].col].getMax(0, 0, MAXVAL, 0, a[i].l);
        s = max(s, mxTree[a[i].col^1].getMax(0,0,MAXVAL, 0, a[i].l));
        s += t;
        mxTree[a[i].col].updateMax(0, 0, MAXVAL, a[i].r, s);
        dp[i] = s;
    }
   // for(int i=0;i<n;i++) cout << dp[i] << " ";cout << endl;
    int f = 0;
    for(int i=1;i<=n;i++) {
        if(dp[f]>=i) {
            ans.push_back(a[f].r);
        }
        else {
            while(f<n&&dp[f]<i) f++;
            if(f==n) {
                for(;i<=n;i++) 
                    ans.push_back(-1);
            }
            else ans.push_back(a[f].r);
        }
    }
    return ans;
}

int main() {
    int cases;
    cin >> cases;
    for(int a0 = 0; a0 < cases; a0++){
        int m;
        int n;
        cin >> m >> n;
        vector<char> t(n);
        for(int t_i = 0; t_i < n; t_i++){
            cin >> t[t_i];
        }
        vector<int> s(n);
        for(int s_i = 0; s_i < n; s_i++){
            cin >> s[s_i];
        }
        vector<int> d(n);
        for(int d_i = 0; d_i < n; d_i++){
            cin >> d[d_i];
        }
        vector <int> result = minimumZooNumbers(m, n, t, s, d);
        for (ssize_t i = 0; i < result.size(); i++) {
            cout << result[i] << (i != result.size() - 1 ? " " : "");
        }
        cout << endl;


    }
    return 0;
}