// [Golem]
#include<bits/stdc++.h>

namespace Golem // [Golem Library] Golem
{
    #define Golem__ 201307
    #define fcc(i, j, k) for(num (i)=(j); (i)<=(k); ++(i))
    #define ccf(i, j, k) for(num (i)=(j); (i)>=(k); --(i))
    #define I (*this)
    #define same_type(T1, T2) (std::is_same<T1, T2>::value)
    #define num_type(T) (same_type(T, num) || same_type(T, Num))
    #define fra_type(T) (same_type(T, fra) || same_type(T, Fra))
    #define num_or_fra_type(T) (num_type(T) || fra_type(T))

    using std::cin, std::cout, std::min, std::max, std::string, std::pair, std::make_pair;
    using num = int;
    using unum = unsigned int;
    using Num = long long;
    using uNum = unsigned long long;
    using fra = double;
    using Fra = long double;
    using pnum = pair<num, num>;
    using pNum = pair<Num, Num>;
    template<typename T>
    using heap = std::priority_queue<T, std::vector<T>, std::greater<T>>;

    const char newl = '\n', *snewl = " \n";

    constexpr Num read()
    {
        Num ret = 0, s = 1, c = getchar();
        if(c == -1) return std::numeric_limits<Num>::min();
        for(; !isdigit(c); c = getchar()) if(c == '-') s = -1;
        for(; isdigit(c); c = getchar()) ret = (ret << 1) + (ret << 3) + (c ^ 48);
        return s * ret;
    }
    constexpr string readstr()
    {
        string ret; char c;
        for(; (c = getchar()) <= ' ';);
        for(; c > ' '; c = getchar()) ret += c;
        return ret;
    }
    template<typename T>
    constexpr void min_(T &a, auto &&b) { if(b < a) a = b; }
    template<typename T>
    constexpr void max_(T &a, auto &&b) { if(a < b) a = b; }
    template<typename Tnf> requires num_or_fra_type(Tnf)
    constexpr Tnf inf() { return (std::numeric_limits<Tnf>::max() - Golem__) / 2; }
    template<typename Tn> requires num_type(Tn)
    constexpr Tn lowbit(Tn i) { return i & -i; }

    template<typename T>
    class array : private std::vector<T>
    {
        public:
        using iterator = std::vector<T>::iterator;
        iterator begin() { return std::vector<T>::begin(); }
        iterator end() { return std::vector<T>::end(); }

        array() { }
        array(num siz) : std::vector<T>(siz) { }
        array(num siz, auto &&t) : std::vector<T>(siz, t) { }
        array(std::initializer_list<T> il) : std::vector<T>(il) { }
        array(T *pb, T *pe) : std::vector<T>(pb, pe) { }
        array(iterator itb, iterator ite) : std::vector<T>(itb, ite) { }

        void clear() { std::vector<T>::clear(); }
        operator bool () { return !I.empty(); }
        num size() { return std::vector<T>::size(); }
        array& set(num siz) { return I.resize(siz), I; }
        T& front() { return std::vector<T>::front(); }
        T& back() { return std::vector<T>::back(); }
        T& operator [] (num i) { return std::vector<T>::operator[](i); }
        void push(auto &&...t) { I.emplace_back(t...); }
        void insert(num i, auto &&...t) { I.emplace(begin() + i, t...); }
        void pop() { I.pop_back(); }
        void erase(num i) { std::vector<T>::erase(begin() + i); }
        void fill(auto &&t) { std::fill(begin(), end(), t); }
        void reverse() { std::reverse(begin(), end()); }
        template<typename Tcom = std::less<T>>
        void sort() { std::sort(begin(), end(), Tcom()); }
        template<typename Tcom = std::less<T>>
        num lower(auto &&t) { return std::lower_bound(begin(), end(), t, Tcom()) - begin(); }
        template<typename Tcom = std::less<T>>
        num upper(auto &&t) { return std::upper_bound(begin(), end(), t, Tcom()) - begin(); }
        template<typename Tcom = std::less<T>>
        void discretize()
        {
            sort<Tcom>(), set(std::unique(begin(), end(),
                [&](T &a, T &b) { return !Tcom()(a, b) && !Tcom()(b, a); }) - begin());
        }
    };

    #define every(e, G, o) for(num (e)=(G).las[(o)]; (e); (e)=(G).pre[(e)])
    template<typename Tn> requires num_type(Tn)
    class graph
    {
        public:
        num V, E; array<num> las, pre, to, fro; array<Tn> wei, cap;

        graph(num V = 0) : V(V), E(0), las(V + 1), pre(2), to(2), fro(2), wei(2), cap(2) { }

        void add(num u, num v, Tn w = 0, Tn c = 0)
        { pre.push(las[u]), las[u] = ++E + 1, to.push(v), fro.push(u), wei.push(w), cap.push(c); }
        void addb(num u, num v, Tn w = 0, Tn c = 0) { add(u, v, w, c), add(v, u, w, c); }
    };
}

namespace Golem // [Golem Library] flow
{
    template<typename Tn> requires num_type(Tn)
    class network : public graph<Tn>
    {
        public:
        void addf(num u, num v, Tn w, Tn c) { I.add(u, v, w, c), I.add(v, u, -w, 0); }
        Tn Dinic(num s, num t)
        {
            array<num> now, dep(I.V + 1); std::queue<num> Q; Tn flo = 0;
            auto BFS = [&]()
            {
                for(dep.fill(0), Q.push(s), dep[s] = 1; !Q.empty();)
                {
                    num o = Q.front(); Q.pop();
                    every(e, I, o) if(I.cap[e] && !dep[I.to[e]])
                        Q.push(I.to[e]), dep[I.to[e]] = dep[o] + 1;
                }
                return dep[t];
            };
            std::function<Tn(num, Tn)> DFS = [&](num o, Tn fl)
            {
                if(o == t || !fl) return fl;
                Tn ret = 0, f;
                for(num e = now[o]; e && fl; e = I.pre[now[o] = e])
                    if(I.cap[e] && dep[I.to[e]] == dep[o] + 1)
                        f = DFS(I.to[e], min(I.cap[e], fl)),
                        I.cap[e] -= f, I.cap[e ^ 1] += f, fl -= f, ret += f;
                if(!ret) dep[o] = 0;
                return ret;
            };
            for(; BFS();) now = I.las, flo += DFS(s, inf<Tn>());
            return flo;
        }
        pair<Tn, Tn> primal_dual(num s, num t)
        {
            array<num> now, vis(I.V + 1); array<Tn> pot(I.V + 1), dis(I.V + 1);
            heap<pair<Tn, num>> H; Tn mf = 0, mc = 0;
            auto Dijkstra = [&]()
            {
                for(dis.fill(inf<Tn>()), H.emplace(dis[t] = 0, t); !H.empty();)
                {
                    num o = H.top().second, v; Tn d = H.top().first, w; H.pop();
                    if(dis[o] == d) every(e, I, o) if(I.cap[e ^ 1])
                    {
                        v = I.to[e], w = I.wei[e ^ 1] + pot[o] - pot[v];
                        if(dis[v] > d + w) H.emplace(dis[v] = d + w, v);
                    }
                }
                return dis[s] < inf<Tn>();
            };
            std::function<Tn(num, Tn)> DFS = [&](num o, Tn fl)
            {
                if(o == t || !fl) return fl;
                Tn ret = 0, f; vis[o] = 1;
                for(num e = now[o]; e && fl; e = I.pre[now[o] = e])
                    if(I.cap[e] && !vis[I.to[e]] && pot[I.to[e]] == pot[o] - I.wei[e])
                        f = DFS(I.to[e], min(I.cap[e], fl)),
                        I.cap[e] -= f, I.cap[e ^ 1] += f, fl -= f, ret += f;
                if(ret) vis[o] = 0;
                return ret;
            };
            fcc(i, 2, I.E + 1) if(I.cap[i] && I.wei[i] < 0)
            {
                std::queue<num> Q;
                for(pot.fill(inf<Tn>()), Q.push(t), pot[t] = 0, vis[t] = 1; !Q.empty();)
                {
                    num o = Q.front(); Q.pop(), vis[o] = 0;
                    every(e, I, o) if(I.cap[e ^ 1] && pot[I.to[e]] > pot[o] + I.wei[e ^ 1])
                    {
                        if(!vis[I.to[e]]) Q.push(I.to[e]), vis[I.to[e]] = 1;
                        pot[I.to[e]] = pot[o] + I.wei[e ^ 1];
                    }
                }
                break;
            }
            for(Tn flo; Dijkstra();)
            {
                fcc(i, 1, I.V) pot[i] += dis[i];
                now = I.las, vis.fill(0), flo = DFS(s, inf<Tn>()), mf += flo, mc += flo * pot[s];
            }
            return make_pair(mf, mc);
        }
    };
}

using namespace Golem;

void solve()
{
    num N = read(), M = read();
    array<num> L(M + 10), C(N * 2 + 10), V(N * 2 + 10);
    fcc(i, 1, M) L[i] = read();
    fcc(i, 1, N * 2) C[i] = read();
    fcc(i, 1, N * 2) V[i] = read();
    num O = N * 4 + M * 2 + 1, S = O + 1, T = S + 1, lb = 0;
    network<Num> G(T);
    fcc(i, 1, N * 2) G.addf(i, i + N * 2, 0, 1E18);
    fcc(i, 1, N * 2 - 1) G.addf(i + N * 2, i + 1, 0, 1E18);
    fcc(i, 1, N * 2)
        G.addf(S, i + N * 2, 0, (i + 1) / 2),
        G.addf(i, T, 0, (i + 1) / 2), lb += (i + 1) / 2;
    G.addf(S, O, 0, N);
    fcc(i, 1, M) G.addf(i + N * 4, i + N * 4 + M, 0, 1E18), G.addf(O, i + N * 4, 0, N);
    fcc(i, 1, M) G.addf(S, i + N * 4 + M, 0, L[i]), G.addf(i + N * 4, T, 0, L[i]), lb += L[i];
    fcc(i, 1, N * 2) G.addf(C[i] + N * 4 + M, i, -V[i], 1);
    pNum ans = G.primal_dual(S, T);
    if(ans.first != lb) cout << -1 << newl;
    else cout << -ans.second << newl;
}
num main()
{
    #ifndef ONLINE_JUDGE
    freopen(".in", "r", stdin);
    freopen(".out", "w", stdout);
    #endif
    std::ios::sync_with_stdio(0), cin.tie(0);

    for(num T = read(); T --> 0;) solve();
    return 0 ^ 0;
}