#include <iostream>
#include <vector>
#include <algorithm>

struct animal_t {
    int k;
    int s;
    int d;

    animal_t(int k, int s, int d) : k(k), s(s), d(d) {
    }
};

struct seg_t {
    int v;
    int x;

    seg_t(int v, int x) : v(v), x(x) {
    }
};

struct segtree_t {
    int size;
    std::vector<seg_t> d;

    segtree_t(int m) {
        size = 2;
        while (size < m) {
            size *= 2;
        }
        d.resize(size * 2, seg_t(0, 0));
    }

    void set(int idx, int v) {
        int pos = idx + size;
        d[pos] = seg_t(v, 0);
        while (pos > 1) {
            int par = pos / 2;
            int lch = par * 2;
            int rch = lch + 1;
            d[par].v = std::max(d[lch].v + d[lch].x, d[rch].v + d[rch].x);
            pos = par;
        }
    }

    void inc(int left, int right, int dx) {
        inc_rec(1, 0, size, left, right, dx);
    }

    void inc_rec(int pos, int cleft, int cright, int left, int right, int dx) {
        if (right <= cleft || left >= cright) {
            return;
        }
        if (left <= cleft && right >= cright) {
            d[pos].x += dx;
        } else {
            int l = cright - cleft;
            int lch = pos * 2;
            int rch = lch + 1;
            inc_rec(lch, cleft, cleft + (l / 2), left, right, dx);
            inc_rec(rch, cleft + (l / 2), cright, left, right, dx);
            d[pos].v = std::max(d[lch].v + d[lch].x, d[rch].v + d[rch].x);
        }
    }

    int query(int left, int right) {
        int res = 0;
        query_rec(1, 0, size, res, left, right);
        return res;
    }

    void query_rec(int pos, int cleft, int cright, int & res, int left, int right) {
        if (right <= cleft || left >= cright) {
            return;
        }
        if (left <= cleft && right >= cright) {
            res = std::max(res, d[pos].v + d[pos].x);
        } else {
            int l = cright - cleft;
            int lch = pos * 2;
            int rch = lch + 1;
            query_rec(lch, cleft, cleft + (l / 2), res, left, right);
            query_rec(rch, cleft + (l / 2), cright, res, left, right);
        }
    }
};

void solve() {
    int m;
    int n;
    scanf("%d", &m);
    scanf("%d", &n);
    std::vector<animal_t> as;
    as.resize(n, animal_t(0, 0, 0));
    for (int i = 0; i < n; ++i) {
        int ch = -1;
        while (ch != 'E' && ch != 'D' && ch != 'C' && ch != 'M') {
            ch = getc(stdin);
        }
        as[i].k = (ch == 'E' || ch == 'C') ? 0 : 1;
    }
    for (int i = 0; i < n; ++i) {
        scanf("%d", &(as[i].s));
        as[i].s -= 1;
    }
    for (int i = 0; i < n; ++i) {
        scanf("%d", &(as[i].d));
        as[i].d -= 1;
    }

    std::sort(as.begin(), as.end(), [](animal_t const& lhv, animal_t const& rhv) {
                return lhv.d < rhv.d;
            });

    std::vector<int> res(n + 1, -1);
    int best = 0;

    segtree_t st0(m);
    segtree_t st1(m);
    std::vector<segtree_t*> st(2, nullptr);
    st[0] = &st0;
    st[1] = &st1;
    int ai = 0;
    for (int i = 0; i < m; ++i) {
        while (ai < n && as[ai].d <= i) {
            auto const& a = as[ai];
            if (a.s < a.d) {
                st[a.k]->inc(0, a.s + 1, 1);
            }
            ++ai;
        }
        int mf = std::max(st0.query(0, i + 1), st1.query(0, i + 1));
        for (int j = best + 1; j <= mf; ++j) {
            res[j] = (i + 1);
        }
        best = mf;
        st0.set(i, mf);
        st1.set(i, mf);
    }

    for (int i = 1; i <= n; ++i) {
        if (i > 1) printf(" ");
        printf("%d", res[i]);
    }
    printf("\n");
}

int main() {
    int t;
    scanf("%d", &t);
    for (int i = 0; i < t; ++i) {
        solve();
    }
    return 0;
}