//#pragma GCC optimize ("Ofast,unroll-loops")
//#pragma GCC target ("avx2")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define notall(x) x.begin()+1,x.end()
#define all(x) x.begin(),x.end()
#define mul_t int _t;cin>>_t;while(_t--)
const int int_inf = 1000000100;
const ll ll_inf = 1000000000000000100;
//writers
template<class T>
void writeln(const T &t) {
    cout << t << '\n';
}
template<class T, class...args>
void writeln(const T &t, const args &...rest) {
    cout << t << ' ';
    writeln(rest...);
}
template<class T1>
void writeln(const vector<T1> &v) {
    for (auto c : v)
        cout << c << ' ';
    cout << ' ' << '\n';
}
template<class T1, class T2>
void writeln(const vector<T1> &v, T2 n) {
    for (T2 i = 1; i <= n; i++)
        cout << v[i] << ' ';
    cout << ' ' << '\n';
}
template<class T1, class T2>
void writeln(const pair<T1, T2> p) {
    cout << p.first << ' ' << p.second << ' ' << '\n';
}

#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
const int RANDOM = chrono::high_resolution_clock::now().time_since_epoch().count();
struct chash {
    int operator()(int x) const { return x ^ RANDOM; }
};
typedef gp_hash_table<int, int,chash> hash_t;

const int maxn=1e5+5;
int n,q,p,x,op;
ll bitsum[maxn];
hash_t col[maxn];
int c[maxn];
ll a[maxn];
void addsum(int pos,ll num)
{
    while(pos<=n)bitsum[pos]+=num,pos+=(pos&-pos);
}

ll querysum(int l,int r)
{
    ll ans=0;
    while(r)
    {
        ans+=bitsum[r],r-=(r&-r);
    }
    --l;
    while(l)
    {
        ans-=bitsum[l],l-=(l&-l);
    }
    return ans;
}

int querycol(int l,int r,vector<int>&cc)
{
    int ans=0;
    while(r)
    {
        for(auto&c:cc)
        {
            ans+=col[r][c];
        }
        r-=(r&-r);
    }
    --l;
    while(l)
    {
        for(auto&c:cc)
        {
            ans-=col[l][c];
        }
        l-=(l&-l);
    }
    return ans;
}

void addcol(int pos,int c,int flag)
{
    while(pos<=n)
    {
        col[pos][c]+=flag;
        if(col[pos][c]==0)col[pos].erase(c);
        pos+=(pos&-pos);
    }
}

void solve(){
    cin>>n>>q;
    for(int i=1;i<=n;i++)
    {
        cin>>c[i];
        addcol(i,c[i],1);
    }
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        addsum(i,a[i]);
    }
    for(int i=1;i<=q;i++)
    {
        cin>>op>>p>>x;
        if(op==1)
        {
            int lst=c[p];
            addcol(p,lst,-1);
            c[p]=x;
            addcol(p,x,1);
        }
        else if(op==2)
        {
            ll lst=a[p];
            addsum(p,-lst);
            a[p]=x;
            addsum(p,x);
        }
        else
        {
            vector<int>nowcol(x);
            for(auto&c:nowcol)cin>>c;
            int l=1,r=p-1,ans=p,ans2=p;
            while(l<=r)
            {
                int mid=(l+r)>>1;
                if(querycol(mid,p,nowcol)==p-mid+1)r=mid-1,ans=mid;
                else l=mid+1;
            }
            l=p+1,r=n;
            while(l<=r)
            {
                int mid=(l+r)>>1;
                if(querycol(p,mid,nowcol)==mid-p+1)l=mid+1,ans2=mid;
                else r=mid-1;
            }
            //writeln(ans,ans2);
            writeln(querysum(ans,ans2));
        }
    }
    fill(bitsum+1,bitsum+n+1,0);
    for(int i=1;i<=n;i++)col[i].clear();
}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout << fixed << setprecision(15);
    mul_t
    solve();
}
/*
1.深呼吸，不要紧张，慢慢读题，读明白题，题目往往比你想的简单。
2.暴力枚举:枚举什么，是否可以使用一些技巧加快枚举速度（预处理、前缀和、数据结构、数论分块）。
3.贪心:需要排序或使用数据结构（pq）吗，这么贪心一定最优吗。
4.二分：满足单调性吗，怎么二分，如何确定二分函数返回值是什么。
5.位运算：按位贪心，还是与位运算本身的性质有关。
6.数学题：和最大公因数、质因子、取模是否有关。
7.dp：怎么设计状态，状态转移方程是什么，初态是什么，使用循环还是记搜转移。
8.搜索：dfs 还是 bfs ，搜索的时候状态是什么，需要记忆化吗。
9.树上问题：是树形dp、树上贪心、或者是在树上搜索。
10.图论：依靠什么样的关系建图，是求环统计结果还是最短路。
11.组合数学：有几种值，每种值如何被组成，容斥关系是什么。
12.交互题：log(n)次如何二分，2*n 次如何通过 n 次求出一些值，再根据剩余次数求答案。
13.如果以上几种都不是，多半是有一个 point 你没有注意到，记住正难则反。
*/