#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


template <class T> void bAdd(vector<T> &bit, int pos, const T &val) {
  const int bitN = bit.size();
  for (int x = pos; x < bitN; x |= x + 1) bit[x] += val;
}
template <class T> T bSum(const vector<T> &bit, int pos) {
  T ret = 0;
  for (int x = pos; x > 0; x &= x - 1) ret += bit[x - 1];
  return ret;
}
template <class T> T bSum(const vector<T> &bit, int pos0, int pos1) {
  return bSum(bit, pos1) - bSum(bit, pos0);
}


#include <ext/pb_ds/assoc_container.hpp>
using __gnu_pbds::gp_hash_table;


int N, Q;
vector<int> C;
vector<Int> V;

int O, P, K;
vector<int> A;

int n;
vector<int> sz;
vector<gp_hash_table<int, int>> seg;
bool check(int u) {
  int sum = 0;
  for (const int c : A) {
    auto it = seg[u].find(c);
    if (it != seg[u].end()) {
      sum += it->second;
    }
  }
// cerr<<"    check "<<u<<": "<<sum<<" "<<sz[u]<<"; ";pv(seg[u].begin(),seg[u].end());
  return (sum < sz[u]);
}

// int findRight(int a, F f, Args &&... args) {
int findRight(int a) {
  assert(0 <= a); assert(a <= n);
  // if ((T().*f)(args...)) return a;
  if (a == n) return n + 1;
  a += n;
  for (; ; a >>= 1) if (a & 1) {
    // if ((ts[a].*f)(args...)) {
    if (check(a)) {
      for (; a < n; ) {
        // if (!(ts[a <<= 1].*f)(args...)) ++a;
        if (!check(a <<= 1)) ++a;
      }
      return a - n + 1;
    }
    ++a;
    if (!(a & (a - 1))) return n + 1;
  }
}
// int findLeft(int b, F f, Args &&... args) {
int findLeft(int b) {
  assert(0 <= b); assert(b <= n);
  // if ((T().*f)(args...)) return b;
  if (b == 0) return -1;
  b += n;
  for (; ; b >>= 1) if ((b & 1) || b == 2) {
    // if ((ts[b - 1].*f)(args...)) {
    if (check(b - 1)) {
      for (; b <= n; ) {
        // if (!(ts[(b <<= 1) - 1].*f)(args...)) --b;
        if (!check((b <<= 1) - 1)) --b;
      }
      return b - n - 1;
    }
    --b;
    if (!(b & (b - 1))) return -1;
  }
}


int main() {
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    scanf("%d%d", &N, &Q);
    C.resize(N); for (int i = 0; i < N; ++i) scanf("%d", &C[i]);
    V.resize(N); for (int i = 0; i < N; ++i) scanf("%lld", &V[i]);
    
    auto bit = V;
    for (int i = 0; i < N; ++i) if ((i | (i + 1)) < N) {
      bit[i | (i + 1)] += bit[i];
    }
    
    for (n = 1; n < N; n <<= 1) {}
    sz.assign(n << 1, 0);
    for (int i = 0; i < N; ++i) {
      sz[n + i] = 1;
    }
    for (int u = n; --u; ) {
      sz[u] = sz[u << 1] + sz[u << 1 | 1];
    }
    seg.assign(n << 1, {});
    for (int i = 0; i < N; ++i) {
      for (int u = n + i; u; u >>= 1) {
        ++seg[u][C[i]];
      }
    }
    
    for (; Q--; ) {
      scanf("%d%d%d", &O, &P, &K);
      --P;
      if (O == 1) {
        for (int u = n + P; u; u >>= 1) {
          --seg[u][C[P]];
          ++seg[u][K];
        }
        C[P] = K;
      } else if (O == 2) {
        bAdd(bit, P, K - V[P]);
        V[P] = K;
      } else if (O == 3) {
        A.resize(K);
        for (int k = 0; k < K; ++k) {
          scanf("%d", &A[k]);
        }
// cerr<<"C = "<<C<<", V = "<<V<<", P = "<<P<<", A = "<<A<<endl;
        int l = findLeft(P) + 1;
        int r = findRight(P + 1) - 1;
        chmax(l, 0);
        chmin(r, N);
// cerr<<"  l = "<<l<<", r = "<<r<<endl;
        const Int ans = bSum(bit, l, r);
        printf("%lld\n", ans);
      } else {
        assert(false);
      }
    }
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}