#include<bits/stdc++.h>
//#pragma GCC optimize("Ofast,unroll-loops")
//#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
//#pragma GCC optimize("Ofast")
//#include<ext/rope>
//#include<bits/extc++.h>
//using namespace __gnu_cxx;
//using namespace __gnu_pbds;
using namespace std;
//typedef tree<long long,null_type,less<long long>,rb_tree_tag,tree_order_statistics_node_update>order_set;
//find_by_order() order_of_key()
//const int maxn=2e3+5;
const int INF=0x3f3f3f3f;
//const int inf=0x3f3f3f3f;
//#define int unsigned int
#define int long long
//#define double int
//#define double long double
const long long LINF=0x3f3f3f3f3f3f3f3f;
#define bit(x) (1LL << (x))
#define lowbit(x) (x & (-x))
#define sq(x) ((x) * (x))
#define pb(i) push_back(i)
#define mk(i,j) make_pair((i),(j))
#define pum(i,j) push(make_pair((i),(j)))
#define pbm(i,j) push_back(make_pair((i),(j)))
#define fup(a,b,c,d) for(int a=(b);a<=(c);a+=(d))
#define fdown(a,b,c,d) for(int a=(b);a>=(c);a-=(d))
typedef unsigned long long ull;
#define ull unsigned ll
using ll = long long;
using pi = pair<int,int>;
using vi = vector<int>;
using vd = vector<double>;
using vc = vector<char>;
using vp = vector<pair<int,int>>;
using vvi = vector<vector<int>>;
using vvd = vector<vector<double>>;
using vvp = vector<vector<pair<int,int>>>;
using vvc = vector<vector<char>>;
using mi = map<int,int>;
using mpi = map<pair<int,int>,int>;
using miv = map<int,vector<int>>;
using mpv = map<pair<int,int>,vi>;
using gi = greater<int>;
using gp = greater<pi>;
using djs_queue =std::priority_queue<pi,vp,gp>;
using ld = long double;
using namespace std;
double eps=1e-15;
double pai=acos(-1.0);
const long long mod=998244353;

long long qpow(long long x,long long y) {
    x%=mod;
    long long res=1;
    while(y){
        if(y&1)res=res*x%mod;
        x=x*x%mod;
        y>>=1;
    }
    return res;
}
const int dx[]={1,0,0,-1,1,1,-1,-1,0};
const int dy[]={0,1,-1,0,-1,1,-1,1,0};

template<typename T>
struct NetWork_Flow{
    struct edge{
        int to,cap,rev;
        T cost;
    };
    int V;
    T Cost=0;
    vector<int>O;
    vector<vector<edge>>adj;
    vector<int>level,iter,asc,prv,pre,vis;
    vector<T>dis;
    void init(int n){
        V=n+10;
        Cost=0;
        O=vector<int>(V+10);
        level=vector<int>(V+10);
        iter=vector<int>(V+10);
        adj=vector<vector<edge>>(V+10);
    }
    void Addedge(int u,int v,int Maxflow,T cost=0,int Minflow=0){
        O[u]-=Minflow;
        O[v]+=Minflow;
        Cost+=cost*Minflow;
        adj[u].push_back({v,Maxflow-Minflow,(int)adj[v].size(),cost});
        adj[v].push_back({u,0,(int)adj[u].size()-1,-cost});
    }
    bool Maxflow_bfs(int s,int t){
        level=vector<int>(V+5);
        queue<int>que;
        level[s]=1;
        que.push(s);
        while(que.size()){
            int u=que.front();
            que.pop();
            for(auto &v:adj[u]){
                if(v.cap>0&&(!level[v.to])){
                    level[v.to]=level[u]+1;
                    que.push(v.to);
                }
            }
        }
        return level[t];
    }
    int Maxflow_dfs(int u,int flow,int t){
        if(u==t||(!flow))return flow;
        for(int &i=iter[u];i<adj[u].size();i++){
            edge &v=adj[u][i];
            if(v.cap>0&&level[v.to]>level[u]){
                int d=Maxflow_dfs(v.to,min(v.cap,flow),t);
                if(d>0){
                    v.cap-=d;
                    adj[v.to][v.rev].cap+=d;
                    return d;
                }
            }
        }
        return 0;
    }
    int Maxflow(int s,int t){
        int flow=0;
        while(Maxflow_bfs(s,t)){
            iter=vector<int>(V+5);
            while(int f=Maxflow_dfs(s,INF,t)){
                flow+=f;
            }
        }
        return flow;
    }
    int Maxflow_Max(int s,int t){
        int Start=t+1,End=t+2;
        for(int i=0;i<=t;i++){
            if(O[i]>0)Addedge(Start,i,O[i]);
            if(O[i]<0)Addedge(i,End,-O[i]);
        }
        Addedge(t,s,INF);
        Maxflow(Start,End);
        int flow1=adj[s].rbegin()->cap;
        for(auto &e:adj[Start])if(e.cap)return -1;
        adj[s].rbegin()->cap=0;
        adj[t].rbegin()->cap=0;
        int flow2=Maxflow(s,t);
        return flow1+flow2;
    }
    int Maxflow_Min(int s,int t){
        int Start=t+1,End=t+2;
        for(int i=0;i<=t;i++){
            if(O[i]>0)Addedge(Start,i,O[i]);
            if(O[i]<0)Addedge(i,End,-O[i]);
        }
        Addedge(t,s,INF);
        Maxflow(Start,End);
        int flow1=adj[s].rbegin()->cap;
        for(auto &e:adj[Start])if(e.cap)return -1;
        adj[s].rbegin()->cap=0;
        adj[t].rbegin()->cap=0;
        int flow2=Maxflow(t,s);
        return flow1-flow2;
    }
    bool MincostMaxflow_dfs(int s,int t,int&flow,T&cost){
        dis=vector<T>(V+5,INF);
        asc=vector<int>(V+5,INF);
        prv=vis=pre=vector<int>(V+5);
        dis[s]=0;
        queue<int>que;
        que.push(s);
        while(que.size()){
            int u=que.front();
            que.pop();
            vis[u]=0;
            for(int i=0;i<adj[u].size();i++){
                edge &v=adj[u][i];
                if(v.cap&&dis[v.to]>dis[u]+v.cost){
                    dis[v.to]=dis[u]+v.cost;
                    asc[v.to]=min(asc[u],v.cap);
                    prv[v.to]=u;
                    pre[v.to]=i;
                    if(!vis[v.to]){
                        que.push(v.to);
                        vis[v.to]=1;
                    }
                }
            }
        }
        if(dis[t]==INF)return false;
        flow+=asc[t];
        cost+=asc[t]*dis[t];
        for(int i=t;i!=s;i=prv[i]){
            edge &e=adj[prv[i]][pre[i]];
            e.cap-=asc[t];
            adj[i][e.rev].cap+=asc[t];
        }
        return true;
    }
    pair<int,T>MincostMaxflow(int s,int t){
        int flow=0;
        T cost=0;
        while(MincostMaxflow_dfs(s,t,flow,cost));
        return {flow,cost};
    }
    T MincostMaxflow_OK(int s,int t){
        int Start=t+1,End=t+2;
        for(int i=0;i<=t;i++){
            if(O[i]>0)Addedge(Start,i,O[i]);
            if(O[i]<0)Addedge(i,End,-O[i]);
        }
        Addedge(t,s,INF);
        pair<long long,long long>flow=MincostMaxflow(Start,End);
        for(auto &e:adj[Start])if(e.cap)return -1;
        return Cost+flow.second;
    }
};



void solve(){
    int n,m;cin>>n>>m;
    vi cnt(m+10),c(2*n+10),v(2*n+10);
    fup(i,1,m,1)cin>>cnt[i];
    fup(i,1,2*n,1)cin>>c[i];
    fup(i,1,2*n,1)cin>>v[i];
    NetWork_Flow<int>mf;
    mf.init(2*n+m+10);
    int limit=2*n+m+1,s=2*n+m+2,t=2*n+m+3;
    mf.Addedge(2*n,t,n,0,n);
    mf.Addedge(s,limit,n,0,n);
    fup(i,1,2*n-1,1)mf.Addedge(i,i+1,min(n,i),0,(i+1)/2);
    fup(i,1,m,1)mf.Addedge(limit,2*n+i,n,0,cnt[i]);
    fup(i,1,2*n-1,1)mf.Addedge(2*n+c[i],i,1,-v[i],0);
    int cost=mf.MincostMaxflow_OK(s,t);
    if(cost!=-1)cout<<-cost<<'\n';
    else cout<<"-1\n";
}


signed main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
//    cout<<fixed<<setprecision(17);
//    clock_t tStart=clock();
//    SetIO("main");
//    freopen("1.in","r",stdin);
//    freopen("1.out","w",stdout);
    int T = 1;
    cin>>T;
//    T=read<int>();
    while(T--){
        solve();
    }
//    cerr<<"\n Time Taken: ";
//    cerr<<fixed<<setprecision(10)<<(double)(clock() - tStart)/CLOCKS_PER_SEC;
}