#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

const ll infl = 1e9;

struct LL {
  ll value;

  LL() : value(-infl) {}

  explicit LL(ll value) : value(value) {}

  LL(const LL& a, const LL& b) {
    value = max(a.value, b.value);
  }
};

struct Add {
  ll value;

  Add() : value(0) {}

  explicit Add(ll value) : value(value) {}

  Add(const Add& a, const Add& b) {
    value = a.value + b.value;
  }
};

void apply(LL& e, const Add& m, int l, int r) {
  e.value += m.value;
  (void) l, (void) r;
}

template<typename E, typename M>
struct ST {
  static constexpr int inf = 1e9;
  int base;
  vector<E> t;
  vector<M> upd;

  static int calc_base(int n) {
    int x = 1;
    while (x < n) {
      x *= 2;
    }
    return x;
  }

  ST() : base(0) {}
  ST(int n) : base(calc_base(n)), t(base * 2), upd(base * 2) {}

  void push(int v, int cl, int cr) {
    int cc = (cl + cr) / 2;
    apply(t[v * 2 + 0], upd[v], cl, cc);
    apply(t[v * 2 + 1], upd[v], cc, cr);
    upd[v * 2 + 0] = M(upd[v * 2 + 0], upd[v]);
    upd[v * 2 + 1] = M(upd[v * 2 + 1], upd[v]);
    upd[v] = M();
  }

  E get(int l, int r, int v = 1, int cl = 0, int cr = inf) {
    cr = min(cr, base);
    if (l <= cl && cr <= r) {
      return t[v];
    }
    if (r <= cl || cr <= l) {
      return E();
    }
    push(v, cl, cr);
    int cc = (cl + cr) / 2;
    return E(get(l, r, v * 2, cl, cc), get(l, r, v * 2 + 1, cc, cr));
  }

  void put(int l, int r, const M& x, int v = 1, int cl = 0, int cr = inf) {
    cr = min(cr, base);
    if (l <= cl && cr <= r) {
      apply(t[v], x, cl, cr);
      upd[v] = M(upd[v], x);
      return;
    }
    if (r <= cl || cr <= l) {
      return;
    }
    push(v, cl, cr);
    int cc = (cl + cr) / 2;
    put(l, r, x, v * 2 + 0, cl, cc);
    put(l, r, x, v * 2 + 1, cc, cr);
    t[v] = E(t[v * 2], t[v * 2 + 1]);
  }

  E& raw_data(int pos) {
    return t[base + pos];
  }

  void build() {
    for (int i = base - 1; i > 0; --i) {
      t[i] = E(t[i * 2], t[i * 2 + 1]);
    }
  }

  void set(int pos, const E& val, int v = 1, int cl = 0, int cr = inf) {
    cr = min(cr, base);
    if (cl + 1 == cr) {
      assert(v == pos + base);
      t[v] = val;
      return;
    }
    push(v, cl, cr);
    int cc = (cl + cr) / 2;
    if (pos < cc) {
      set(pos, val, v * 2, cl, cc);
    } else {
      set(pos, val, v * 2 + 1, cc, cr);
    }
    t[v] = E(t[v * 2], t[v * 2 + 1]);
  }
};
using Tree = ST<LL, Add>;

const int maxn = 100100;
vector<pair<int, int>> qs[maxn];

vector<int> minimumZooNumbers(int n, int m, vector<char> _t, vector<int> _s, vector<int> _d) {
  --n;
  for (int i = 0; i <= n; ++i) {
    qs[i].clear();
  }
  for (int i = 0; i < m; ++i) {
    int tp = _t[i] == 'E' || _t[i] == 'C';
    if (_s[i] > _d[i]) {
      continue;
    }
    int l = _s[i] - 1;
    int r = _d[i] - 1;
    qs[r].emplace_back(l, tp);
  }
  vector<int> ans(m + 1, 1e9);
  Tree t[2];
  t[0] = Tree(n + 1);
  t[1] = Tree(n + 1);
  t[0].set(0, LL(0));
  t[1].set(0, LL(0));
  for (int i = 0; i <= n; ++i) {
    for (auto p : qs[i]) {
      int l = p.first;
      int tp = p.second;
      t[tp].put(0, l + 1, Add(1));
    }
    ll val0 = t[0].get(0, n + 1).value;
    ll val1 = t[1].get(0, n + 1).value;
    ll val = max(val0, val1);
    //cerr << i << ' ' << val << '\n';
    t[0].set(i, LL(val));
    t[1].set(i, LL(val));
    ans[val] = min(ans[val], i + 1);
  }
  for (int i = m - 1; i >= 0; --i) {
    ans[i] = min(ans[i], ans[i + 1]);
  }
  for (int i = 0; i <= m; ++i) {
    if (ans[i] == 1e9) {
      ans[i] = -1;
    }
  }
  ans.erase(ans.begin());
  return ans;
}

int main() {
#ifdef LOCAL
  assert(freopen("e.in", "r", stdin));
#endif
  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 (int i = 0; i < (int) result.size(); i++) {
      cout << result[i] << (i != (int) result.size() - 1 ? " " : "");
    }
    cout << endl;
  }
  return 0;
}