#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define int i64
constexpr i64 inf = 1e10;
constexpr i64 maxv = 2e9;
template<class T>
 struct MinCostFlow {
    struct _Edge {
        int to;
        T cap;
        T cost;
        _Edge(int to_, T cap_, T cost_) : to(to_), cap(cap_), cost(cost_) {}
    };
    int n;
    vector<_Edge> e;
    vector<vector<int>> g;
    vector<T> h, dis;
    vector<int> pre;
    bool dijkstra(int s, int t) {
        dis.assign(n, numeric_limits<T>::max());
        pre.assign(n, -1);
        priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> que;
        dis[s] = 0;
        que.emplace(0, s);
        while (!que.empty()) {
            T d = que.top().first;
            int u = que.top().second;
            que.pop();
            if (dis[u] != d) {
                continue;
            }
            for (int i : g[u]) {
                int v = e[i].to;
                T cap = e[i].cap;
                T cost = e[i].cost;
                if (cap > 0 && dis[v] > d + h[u] - h[v] + cost) {
                    dis[v] = d + h[u] - h[v] + cost;
                    pre[v] = i;
                    que.emplace(dis[v], v);
                }
            }
        }
        return dis[t] != numeric_limits<T>::max();
    }
    MinCostFlow() {}
    MinCostFlow(int n_) {
        init(n_);
    }
    void init(int n_) {
        n = n_;
        e.clear();
        g.assign(n, {});
    }
    void addEdge(int u, int v, T cap, T cost) {
        g[u].push_back(e.size());
        e.emplace_back(v, cap, cost);
        g[v].push_back(e.size());
        e.emplace_back(u, 0, -cost);
    }
    pair<T, T> flow(int s, int t) {
        T flow = 0;
        T cost = 0;
        h.assign(n, 0);
        while (dijkstra(s,t)) {
            for (int i = 0; i < n; ++i) {
                h[i] += dis[i];
            }
            T aug = numeric_limits<int>::max();
            for (int i = t; i != s; i = e[pre[i] ^ 1].to) {
                aug = min(aug, e[pre[i]].cap);
            }
            for (int i = t; i != s; i = e[pre[i] ^ 1].to) {
                e[pre[i]].cap -= aug;
                e[pre[i] ^ 1].cap += aug;
            }
            flow += aug;
            cost += aug * h[t];
        }
        return make_pair(flow, cost);
    }
    struct Edge {
        int from;
        int to;
        T cap;
        T cost;
        T flow;
    };
    vector<Edge> edges() {
        vector<Edge> a;
        for (int i = 0; i < e.size(); i += 2) {
            Edge x;
            x.from = e[i + 1].to;
            x.to = e[i].to;
            x.cap = e[i].cap + e[i + 1].cap;
            x.cost = e[i].cost;
            x.flow = e[i + 1].cap;
            a.push_back(x);
        }
        return a;
    }
 };
void solve()
{
    i64 n,m;cin>>n>>m;
    int S = 0, T = n*2+m+2;
    int SS = T+1, TT = T+2;
    MinCostFlow<i64> flow(T+3);
    vector<int> in(n*2+1+m+2);
    vector<int> out(n*2+1+m+2);
    vector<int> val(n*2),cor(n*2),limit(m+1);
    for(int i=1;i<=m;i++)   cin>>limit[i];
    for(int i=1;i<=2*n;i++)   cin>>cor[i];
    for(int i=1;i<=2*n;i++)   cin>>val[i];
    auto boundflow = [&](int u,int v,int L, int R, int cost)
    {
        out[u] += L;
        in[v] += L;
        flow.addEdge(u,v,R-L,cost);
    };
    for(int i=1;i<=2*n;i++)   
    {
        boundflow(i,i+1,(i+1)/2,n,0);
        boundflow(cor[i]+2*n+1,i,0,1,((maxv-val[i])<<10)+1);
    }
    for(int i=1+(2*n+1);i<=m+(2*n+1);i++)
        boundflow(S,i,limit[i-(2*n+1)],inf,0);
    boundflow(2*n+1,T,n,n,0);

    for(int i=S;i<=T;i++)
    {
        if(in[i]>out[i])
            flow.addEdge(SS,i,in[i] - out[i],0);
        else if(in[i]<out[i])
            flow.addEdge(i,TT,out[i]-in[i],0);
    }
    flow.addEdge(T,S,inf,0);
    auto res1 = flow.flow(SS,TT);
    for(auto c:flow.edges())    
        if(c.from==SS&&c.flow!=c.cap)
            return cout<<"-1\n",void();
    int tot =  res1.second;
    int cnt = tot % (1<<10);
    tot = cnt * maxv - (tot>>10);
    cout<<tot<<"\n";
}
signed main()
{
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int T = 1;
    cin>>T;
    while(T--)
        solve();
}