#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>    // 包含 tree、gp_hash_table、cc_hash_table
#include <ext/pb_ds/priority_queue.hpp> // 引入后使用 STL 的堆需要 std::
#include <ext/rope>
using namespace __gnu_pbds;
using namespace __gnu_cxx;
using namespace std;
template<class key, class val = null_type, class cmp = less<>>
using rb_tree = tree<key, val, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template<class key, class cmp = less<>>
using pairing_heap = __gnu_pbds::priority_queue<key, cmp>;
typedef long long ll;
#define int long long
template<class T> void print_debug(const T & v) { cerr << v; }
template<class T, class ... A> void print_debug(const T & v, const A & ... a) { cerr << v << ", ", print_debug(a...); }
#define debug(...) (cerr << "[" << #__VA_ARGS__ << "] = [", print_debug(__VA_ARGS__), cerr << "]\n")
mt19937_64 rd(time(0));

struct KMP : vector<int> {  // 数组表示 S[:i] 最长真前缀和真后缀的长度
    KMP(const string & s = "") : vector(s.size()) { // 从 0 开始，前缀函数
        for (int i = 1; i < size(); at(i++) += s[i] == s[at(i)]) {
            for (at(i) = at(i - 1); at(i) && s[i] != s[at(i)]; at(i) = at(at(i) - 1));
        }
    }
    KMP(const string & t, const string & s, char o = '#') : KMP(t + o + s) {}
};

struct ZFun : vector<int> { // 数组表示 S 与 S[i:] 最长公共前缀 (LCP)
    ZFun(const string & s = "") : vector(s.size()) {    // 从 0 开始
        at(0) = s.size();
        for (int i = 1, j = 1; i < size(); i++) {
            for (at(i) = max<int>(0, min(at(j) + j - i, at(i - j))); i + at(i) < size() && s[at(i)] == s[i + at(i)]; at(i)++);
            if (i + at(i) > j + at(j)) j = i;
        }
    }
    ZFun(const string & t, const string & s, char o = '#') : ZFun(t + o + s) {}
};

struct Manacher : vector<int> { // 从 0 开始，得到所在的回文串总长度（去除 o ）
    Manacher(const string & s = "", char o = '#') : vector(2 * s.size() + 1) {
        string t(1, o);
        for (auto & c : s) t += c, t += o;
        for (int i = 0, j = 0; i < size(); i++) {
            if (2 * j - i >= 0 && j + at(j) > i) at(i) = min(at(2 * j - i), at(j) + j - i);
            for ( ; i - at(i) >= 0 && i + at(i) < size() && t[i - at(i)] == t[i + at(i)]; at(i)++);
            if (i + at(i) > j + at(j)) j = i;
        }
        for (auto & x : *this) x--;
    }
};

const int mod = 998244353;

auto binpow = [](int a, int b, int res = 1) {
    for (a %= mod; b; b >>= 1, (a *= a) %= mod) {
        if (b & 1) (res *= a) %= mod;
    }
    return res;
};

template<class type = int>
struct Dinic : vector<vector<int>> {    // O(n^2 * m)，二分图最大匹配 O(n^0.5 * m)
    struct Edge {
        int v;
        type c;
        Edge(int v, type c) : v(v), c(c) {}
    };

    vector<Edge> e;
    vector<int> cur, h;
    Dinic(int n) : vector(n) {}
    void add(int u, int v, type c) {
        at(u).emplace_back(e.size()), e.emplace_back(v, c);
        at(v).emplace_back(e.size()), e.emplace_back(u, 0);
    }

    int bfs(int & s, int & t) {
        h.assign(size(), numeric_limits<int>::max());
        queue<int> q;
        h[s] = 0, q.emplace(s);
        while (q.size()) {
            int u = q.front(); q.pop();
            for (auto & i : at(u)) {
                auto & [v, c] = e[i];
                if (c > 0 && h[v] > h[u] + 1) h[v] = h[u] + 1, q.emplace(v);
            }
        }
        return h[t] != numeric_limits<int>::max();
    }
    type dfs(int u, int & t, type flow) {
        if (u == t) return flow;
        type ret = flow, a;
        for (int & i = cur[u]; i < at(u).size(); i++) {
            auto & [v, c] = e[at(u)[i]];
            if (c > 0 && h[v] == h[u] + 1 && (a = dfs(v, t, min(ret, c)))) {
                ret -= a, c -= a, e[at(u)[i] ^ 1].c += a;
                if (ret == 0) return flow;
            }
        }
        return flow - ret;
    }
    type maxflow(int s, int t, type flow = 0) {
        while (bfs(s, t)) {
            cur.assign(size(), 0), flow += dfs(s, t, numeric_limits<type>::max());
        }
        return flow;
    }
};

template<class type = int>
struct ISAP : vector<vector<int>> { // O(n^2 * m)
    struct Edge {
        int v;
        type c;
        Edge(int v, type c) : v(v), c(c) {}
    };

    vector<Edge> e;
    vector<int> cur, h, gap;
    ISAP(int n) : vector(n) {}
    void add(int u, int v, type c) {
        at(u).emplace_back(e.size()), e.emplace_back(v, c);
        at(v).emplace_back(e.size()), e.emplace_back(u, 0);
    }

    void bfs(int & t) {   // 反向bfs
        h.assign(size(), numeric_limits<int>::max()), gap.assign(size() + 2, 0);
        queue<int> q;
        h[t] = 0, gap[h[t]]++, q.emplace(t);
        while (q.size()) {
            int u = q.front(); q.pop();
            for (auto & i : at(u)) {
                auto & [v, c] = e[i];
                if (e[i ^ 1].v && h[v] > h[u] + 1) h[v] = h[u] + 1, gap[h[v]]++, q.emplace(v);
            }
        }
    }
    type dfs(int u, int & s, int & t, type flow) {
        if (u == t) return flow;
        type ret = flow, a;
        for (int & i = cur[u]; i < at(u).size(); i++) {
            auto & [v, c] = e[at(u)[i]];
            if (c > 0 && h[v] + 1 == h[u] && (a = dfs(v, s, t, min(ret, c)))) {
                ret -= a, c -= a, e[at(u)[i] ^ 1].c += a;
                if (ret == 0) return flow;
            }
        }
        if (--gap[h[u]] == 0) h[s] = size();
        return gap[++h[u]]++, flow - ret;
    }
    type maxflow(int s, int t, type flow = 0) {
        for (bfs(t); h[s] < size(); ) {
            cur.assign(size(), 0), flow += dfs(s, s, t, numeric_limits<type>::max());
        }
        return flow;
    }
};

template<class type = int>
struct HLPP : vector<vector<int>> { // O(n^2 * sqrt(m))
    struct Edge {
        int v;
        type c;
        Edge(int v, type c) : v(v), c(c) {}
    };

    vector<Edge> e;
    vector<int> h, gap;
    int level = 0;
    vector<type> ex;
    vector<stack<int>> B;
    HLPP(int n) : vector(n) {}
    void add(int u, int v, type c) {
        at(u).emplace_back(e.size()), e.emplace_back(v, c);
        at(v).emplace_back(e.size()), e.emplace_back(u, 0);
    }

    int bfs(int & s, int & t) {   // 反向bfs
        h.assign(size(), numeric_limits<int>::max()), gap.assign(size() + 2, 0);
        queue<int> q;
        h[t] = 0, gap[h[t]]++, q.emplace(t);
        while (q.size()) {
            int u = q.front(); q.pop();
            for (auto & i : at(u)) {
                auto & [v, c] = e[i];
                if (e[i ^ 1].v && h[v] > h[u] + 1) h[v] = h[u] + 1, gap[h[v]]++, q.emplace(v);
            }
        }
        return h[s] != numeric_limits<int>::max();
    }
    int push(int u, int & s, int & t) {
        int init = u == s;
        for (auto & i : at(u)) {
            auto & [v, c] = e[i];
            if (!init && h[u] != h[v] + 1 || !c || h[v] == numeric_limits<int>::max()) continue;
            type k = init ? c : min(c, ex[u]);
            if (v != s && v != t && !ex[v]) B[h[v]].push(v), level = max(level, h[v]);
            ex[u] -= k, ex[v] += k, c -= k, e[i ^ 1].c += k;
            if (!ex[u]) return 0;
        }
        return 1;
    }
    void relabel(int u) {
        h[u] = numeric_limits<int>::max();
        for (auto & i : at(u)) {
            if (e[i].c) h[u] = min(h[u], h[e[i].v]);
        }
        if (++h[u] < size()) B[h[u]].push(u), level = max(level, h[u]), ++gap[h[u]];
    }
    int slect() {
        for ( ; level > -1 && B[level].size() == 0; level--);
        return level == -1 ? 0 : B[level].top();
    }
    type maxflow(int s, int t, type flow = 0) {
        if (!bfs(s, t)) return 0;
        ex.assign(size(), 0), B.assign(size(), stack<int>());
        h[s] = size(), push(s, s, t);
        for (int u = 0; u = slect(); ) {
            B[level].pop();
            if (push(u, s, t)) {
                if (--gap[h[u]] == 0) for (int i = 0; i < size(); i++) {
                    if (i != s && h[i] > h[u] && h[i] < size() + 1) h[i] = size() + 1;
                }
                relabel(u);
            }
        }
        return ex[t];
    }
};

template <class type = int>
struct MCMF : vector<vector<int>> {
    struct Edge {
        int v;
        type c, f;  // 容量，费用
        Edge(int v, type c, type f) : v(v), c(c), f(f) {}
    };

    vector<Edge> e;
    vector<type> h, dis;
    vector<int> pre;
    MCMF(int n) : vector(n) {}
    void add(int u, int v, type c, type f) {
        at(u).emplace_back(e.size()), e.emplace_back(v, c, f);
        at(v).emplace_back(e.size()), e.emplace_back(u, 0, -f);
    }

    int dijkstra(int & s, int & t) {
        dis.assign(size(), numeric_limits<type>::max()), pre.assign(size(), -1);
        std::priority_queue<pair<type, int>, vector<pair<type, int>>, greater<>> q;
        dis[s] = 0, q.emplace(0, s);
        while (q.size()) {
            auto [d, u] = q.top(); q.pop();
            if (dis[u] < d) continue;
            for (auto & i : at(u)) {
                auto & [v, c, f] = e[i];
                if (c > 0 && dis[v] > d + h[u] - h[v] + f) {
                    dis[v] = d + h[u] - h[v] + f, pre[v] = i;
                    q.emplace(dis[v], v);
                }
            }
        }
        return dis[t] != numeric_limits<type>::max();
    }
    void spfa(int & s, int & t) {   // 存在负权边
        h.assign(size(), numeric_limits<type>::max());
        vector<int> vis(size());
        queue<int> q;
        h[s] = 0, vis[s] = 1, q.push(s);
        while (q.size()) {
            int u = q.front(); q.pop(), vis[u] = 0;
            for (auto & i : at(u)) {
                auto & [v, c, f] = e[i];
                if (c > 0 && h[v] > h[u] + f) {
                    h[v] = h[u] + f;
                    if (!vis[v]) vis[v] = 1, q.push(v);
                }
            }
        }
    }
    array<type, 2> mncmxf(int s, int t, int flag, type flow = 0, type cost = 0) {
        if (flag) spfa(s, t);   // 若存在负权边，也可以使用消负权法
        else h.assign(size(), 0);   // 若全为正权值
        while (dijkstra(s, t)) {
            type a = numeric_limits<type>::max();
            for (int i = 0; i < size(); h[i++] += dis[i]);
            for (int i = t; i != s; a = min(a, e[pre[i]].c), i = e[pre[i] ^ 1].v);
            for (int i = t; i != s; i = e[pre[i] ^ 1].v) {
                e[pre[i]].c -= a, e[pre[i] ^ 1].c += a;
            }
            flow += a, cost += a * h[t];
        }
        return {flow, cost};
    }
};

void QAQ() {
    int n, m;
    cin >> n >> m;

    int ts = 0, t = 2 * n + m, s = t + 1, S = s + 1, T = S + 1;

    MCMF adj(T + 1);

    vector<int> l(T + 1), c(2 * n + 1), v(2 * n + 1), in(T + 1);

    adj.add(s, ts, 0, 0);
    in[ts] += n;
    adj.add(s, T, n, 0);

    for (int i = 1; i <= m; i++) {
        cin >> l[i];
        adj.add(ts, i, n - l[i], 0);
        in[ts] -= l[i], in[i] += l[i];
    }

    for (int i = 1; i <= 2 * n; i++) {
        cin >> c[i];
    }
    for (int i = 1; i <= 2 * n; i++) {
        cin >> v[i];
        adj.add(c[i], i + m, 1, -v[i]);
    }

    for (int i = 1; i < 2 * n; i++) {
        in[i + m] -= (i + 1) / 2, in[i + 1 + m] += (i + 1) / 2;
        adj.add(i + m, i + 1 + m, n - (i + 1) / 2, 0);
    }
    int tot = 0;
    for (int i = 0; i <= T; i++) {
        if (in[i] > 0) tot += in[i], adj.add(S, i, in[i], 0);
        else if (in[i] < 0) adj.add(i, T, -in[i], 0);
    }

    adj.add(t, s, numeric_limits<int>::max(), 0);

    auto [flow, cost] = adj.mncmxf(S, T, 1);
    if (flow < tot) cout << "-1\n";
    else {
        int maxflow = adj.e.back().c;
        adj[s].pop_back(), adj[t].pop_back(), adj.e.pop_back(), adj.e.pop_back();
        if (maxflow != n) {
            cout << "-1\n";
        } else {
            cout << -cost << "\n";
        }
    }
}

signed main() {
    cin.tie(0) -> sync_with_stdio(0);
    cout << fixed << setprecision(12);
    int t = 1;
    cin >> t;

    while (t--) {
        QAQ();
    }
}