#include <bits/stdc++.h>
using namespace std;
using i128 = __int128_t;

static i128 INF128 = ( (i128)1 << 80 );

struct Node {
    bool empty;
    i128 sum;
    array<i128,7> t1;
    array<i128,7> t2;
    Node(): empty(true), sum(0) { t1.fill(0); t2.fill(0); }
};

inline Node make_leaf(i128 C, int idx) {
    Node nd;
    nd.empty = false;
    nd.sum = C;
    // t1 and t2 both set to (C,C,C,i+1,i,i+1,i)
    nd.t1 = {C, C, C, (i128)(idx+1), (i128)idx, (i128)(idx+1), (i128)idx};
    nd.t2 = nd.t1;
    return nd;
}

// combine function (op)
Node combine(const Node &A, const Node &B) {
    if (A.empty) return B;
    if (B.empty) return A;
    Node C;
    C.empty = false;
    i128 sa = A.sum;
    i128 sb = B.sum;
    C.sum = sa + sb;
    // compute first tuple (based on Python op's first block)
    {
        // unpack
        i128 m0=A.t1[0], m1=A.t1[1], m2=A.t1[2], r0=A.t1[3], l1=A.t1[4], r1=A.t1[5], l2=A.t1[6];
        i128 m0_=B.t1[0], m1_=B.t1[1], m2_=B.t1[2], r0_=B.t1[3], l1_=B.t1[4], r1_=B.t1[5], l2_=B.t1[6];
        i128 tm0, tm1, tm2, tr0, tl1, tr1, tl2;
        // tm0
        if (m0 >= sa + m0_) { tm0 = m0; tr0 = r0; }
        else { tm0 = sa + m0_; tr0 = r0_; }
        // tm2
        if (m2_ >= sb + m2) { tm2 = m2_; tl2 = l2_; }
        else { tm2 = sb + m2; tl2 = l2; }
        // tm1
        if (m1 >= m1_ && m1 >= m2 + m0_) {
            tm1 = m1; tl1 = l1; tr1 = r1;
        } else if (m1_ >= m1 && m1_ >= m2 + m0_) {
            tm1 = m1_; tl1 = l1_; tr1 = r1_;
        } else {
            tm1 = m2 + m0_; tl1 = l2; tr1 = r0_;
        }
        C.t1 = {tm0, tm1, tm2, tr0, tl1, tr1, tl2};
    }
    // compute second tuple (based on Python op's second block: using A[2], B[2])
    {
        i128 m0=A.t2[0], m1=A.t2[1], m2=A.t2[2], r0=A.t2[3], l1=A.t2[4], r1=A.t2[5], l2=A.t2[6];
        i128 m0_=B.t2[0], m1_=B.t2[1], m2_=B.t2[2], r0_=B.t2[3], l1_=B.t2[4], r1_=B.t2[5], l2_=B.t2[6];
        i128 tm0, tm1, tm2, tr0, tl1, tr1, tl2;
        if (m0 <= sa + m0_) { tm0 = m0; tr0 = r0; }
        else { tm0 = sa + m0_; tr0 = r0_; }
        if (m2_ <= sb + m2) { tm2 = m2_; tl2 = l2_; }
        else { tm2 = sb + m2; tl2 = l2; }
        if (m1 <= m1_ && m1 <= m2 + m0_) {
            tm1 = m1; tl1 = l1; tr1 = r1;
        } else if (m1_ <= m1 && m1_ <= m2 + m0_) {
            tm1 = m1_; tl1 = l1_; tr1 = r1_;
        } else {
            tm1 = m2 + m0_; tl1 = l2; tr1 = r0_;
        }
        C.t2 = {tm0, tm1, tm2, tr0, tl1, tr1, tl2};
    }
    return C;
}

// mapping function: apply lazy f (0 or 1) to a node
inline Node apply_map(int f, const Node &nd) {
    if (nd.empty) return nd;
    if (f == 0) return nd;
    Node c;
    c.empty = false;
    c.sum = - nd.sum;
    // c.t1 from nd.t2 with first three negated, last four same
    c.t1 = nd.t2;
    c.t1[0] = -c.t1[0];
    c.t1[1] = -c.t1[1];
    c.t1[2] = -c.t1[2];
    // c.t2 from nd.t1
    c.t2 = nd.t1;
    c.t2[0] = -c.t2[0];
    c.t2[1] = -c.t2[1];
    c.t2[2] = -c.t2[2];
    return c;
}

struct LazySegTree {
    int n;
    int logn;
    int size;
    vector<Node> d;
    vector<int> lz; // lazy values (0 or 1), composition is xor

    LazySegTree() = default;

    LazySegTree(const vector<Node> &v) {
        n = (int)v.size();
        logn = 0;
        while ((1<<logn) < n) ++logn;
        size = 1<<logn;
        d.assign(2*size, Node());
        lz.assign(size, 0);
        for (int i = 0; i < n; ++i) d[size + i] = v[i];
        for (int i = size - 1; i >= 1; --i) {
            d[i] = combine(d[2*i], d[2*i+1]);
        }
    }

    void _all_apply(int k, int f) {
        d[k] = apply_map(f, d[k]);
        if (k < size) {
            lz[k] ^= f; // composition is xor
        }
    }
    void _push(int k) {
        if (lz[k] != 0) {
            _all_apply(2*k, lz[k]);
            _all_apply(2*k+1, lz[k]);
            lz[k] = 0;
        }
    }
    void _update(int k) {
        d[k] = combine(d[2*k], d[2*k+1]);
    }

    Node all_prod() {
        return d[1];
    }

    // apply f to [l, r) (0-indexed)
    void apply_range(int l, int r, int f) {
        if (l >= r) return;
        l += size; r += size;
        // push down
        for (int i = logn; i >= 1; --i) {
            if (((l >> i) << i) != l) _push(l >> i);
            if (((r >> i) << i) != r) _push((r-1) >> i);
        }
        int L = l, R = r;
        while (l < r) {
            if (l & 1) { _all_apply(l, f); l++; }
            if (r & 1) { --r; _all_apply(r, f); }
            l >>= 1; r >>= 1;
        }
        // update up
        for (int i = 1; i <= logn; ++i) {
            if (((L >> i) << i) != L) _update(L >> i);
            if (((R >> i) << i) != R) _update((R-1) >> i);
        }
    }
};

string to_string_i128(i128 x) {
    if (x == 0) return "0";
    bool neg = false;
    if (x < 0) { neg = true; x = -x; }
    string s;
    while (x > 0) {
        int digit = (int)(x % 10);
        s.push_back('0' + digit);
        x /= 10;
    }
    if (neg) s.push_back('-');
    reverse(s.begin(), s.end());
    return s;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int T;
    if (!(cin >> T)) return 0;
    while (T--) {
        int n_in, k;
        cin >> n_in >> k;
        vector<i128> A(n_in);
        vector<i128> B(n_in);
        for (int i = 0; i < n_in; ++i) { long long t; cin >> t; A[i] = (i128)t; }
        for (int i = 0; i < n_in; ++i) { long long t; cin >> t; B[i] = (i128)t; }

        bool odd = (k % 2 != 0);
        int n = n_in;
        if (odd) {
            // extend
            A.push_back((i128)0);
            B.push_back(INF128);
            n = n_in + 1;
            k = k + 1;
        }

        // compute ans = sum(A)
        i128 ans = 0;
        for (int i = 0; i < n; ++i) ans += A[i];

        // C = B - A
        vector<i128> C(n);
        for (int i = 0; i < n; ++i) C[i] = B[i] - A[i];

        // build lst
        vector<Node> lst;
        lst.reserve(n);
        for (int i = 0; i < n; ++i) {
            lst.push_back(make_leaf(C[i], i));
        }

        LazySegTree st(lst);

        int loops = k / 2;
        for (int it = 0; it < loops; ++it) {
            Node rep = st.all_prod();
            if (rep.empty) break;
            // extract l = rep.t1[4], r = rep.t1[5]
            i128 m1 = rep.t1[1];
            if (m1 < 0) break;
            i128 l128 = rep.t1[4];
            i128 r128 = rep.t1[5];
            // these were stored as small ints; cast to int
            int l = (int)l128;
            int r = (int)r128;
            ans += m1;
            // apply [l, r) with f = 1
            if (l < r) st.apply_range(l, r, 1);
        }

        if (odd) {
            // result = main(...) - (1<<80)
            ans -= INF128;
        }

        cout << to_string_i128(ans) << '\n';
    }
    return 0;
}