#include "bits/stdc++.h"
using namespace std;

#define ll long long
#define MOD 998244353
#define pii pair<int, int>

#define inf 0x7fffffffffffffff

#define N 110

struct Edge {
    int u, v;
    ll c, x;
    Edge(int u, int v, ll c, ll x): u(u), v(v), c(c), x(x) {}
};

struct MCMF {
    int n, m;
    vector<Edge> E;
    vector<int> G[N];
    int pre[N], inq[N];
    ll f[N], dis[N], flow, cost;
    
    void init(int n) {
        this->n = n;
        this->m = 0;
        E.clear();
        for (int i = 1; i <= n; ++ i) G[i].clear();
    }

    int add_edge(int u, int v, ll c, ll x) {
        assert(c >= 0);
        E.emplace_back(u, v, c, x);
        E.emplace_back(v, u, 0, -x);
        G[u].emplace_back(m ++);
        G[v].emplace_back(m ++);
        return m - 2;
    }

    bool spfa(int s, int t) {
        for (int i = 1; i <= n; ++ i) {
            inq[i] = 0;
            f[i] = 0;
            dis[i] = inf;
        }

        queue<int> q; q.push(s);
        f[s] = inf, dis[s] = 0;
        
        while (!q.empty()) {
            int u = q.front(); q.pop();
            inq[u] = 0;
            for (auto e : G[u]) {
                auto [_, v, c, x] = E[e];
                if (c && dis[u] + x < dis[v]) {
                    pre[v] = e;
                    f[v] = min(f[u], c);
                    dis[v] = dis[u] + x;
                    if (!inq[v]) {
                        q.push(v);
                        inq[v] = 1;
                    }
                }
            }
        }

        return dis[t] != inf;
    }

    void go(int s, int t) {
        flow = 0, cost = 0;
        while (spfa(s, t)) {
            flow += f[t];
            cost += f[t] * dis[t];
            
            for (int u = t; u != s; u = E[pre[u]].u) {
                int e = pre[u];
                E[e].c -= f[t], E[e^1].c += f[t];
            }
        }
    }
};

struct exMCMF {
    ll imo[N];
    MCMF cls;
    int n, s, t, S, T;
    ll flow, cost;

    void init(int n, int s, int t) {
        this->n = n;
        this->s = s;
        this->t = t;
        S = n+1, T = n+2;
        memset(imo, 0, sizeof imo);
        cls.init(n+2);
    }

    void add_edge(int u, int v, ll l, ll r, ll x) {
        imo[u] -= l, imo[v] += l;
        cls.add_edge(u, v, r - l, x);
    }

    bool mcf() {
        ll tarf = 0;
        for (int i = 1; i <= n; ++ i) {
            if (imo[i] > 0) cls.add_edge(S, i, imo[i], 0), tarf += imo[i];
            if (imo[i] < 0) cls.add_edge(i, T, -imo[i], 0);
        }
        add_edge(t, s, 0, inf, 0);

        cls.go(S, T);
        flow = cls.E[cls.m - 1].c, cost = cls.cost;
        
        return cls.flow == tarf;
    }

    bool mcmf() {
        if (!mcf()) return 0;
        cls.E[cls.m - 1].c = 0;
        cls.E[cls.m - 2].c = 0;

        cls.go(s, t);
        flow += cls.flow, cost += cls.cost;

        return 1;
    }
};

exMCMF exmcmf;

int c[N], v[N];

int main() {
#ifdef TEST
    freopen("zz.in", "r+", stdin);
#endif
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int t; cin >> t;
    while (t --) {
        int n, m; cin >> n >> m;
        int s = m + 2 * n + 1, t = s + 1;

        exmcmf.init(t, s, t);
        for (int i = 1; i <= m; ++ i) {
            int l; cin >> l;
            exmcmf.add_edge(s, i, l, inf, 0);
        }
        
        for (int i = 1; i <= 2 * n; ++ i) cin >> c[i];
        for (int i = 1; i <= 2 * n; ++ i) cin >> v[i];

        for (int i = 1; i <= 2 * n; ++ i) {
            exmcmf.add_edge(c[i], m+i, 0, 1, -v[i]);
        }
        for (int i = 1; i < 2 * n; ++ i) {
            exmcmf.add_edge(m+i, m+i+1, (i+1)/2, min(i, n), 0);
        }
        exmcmf.add_edge(m+2*n, t, n, n, 0);


        if (exmcmf.mcf()) {
            cout << -exmcmf.cost << '\n';
        } else {
            cout << -1 << '\n';
        }
    }

    return 0;
}