#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cctype>

#include <algorithm>
#include <random>
#include <bitset>
#include <queue>
#include <functional>
#include <set>
#include <map>
#include <vector>
#include <chrono>
#include <iostream>
#include <limits>
#include <numeric>

#define LOG(FMT...) fprintf(stderr, FMT)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

template<class T>
istream &operator>>(istream &is, vector<T> &v) {
  for (T &x : v)
    is >> x;
  return is;
}

template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
  if (!v.empty()) {
    os << v.front();
    for (int i = 1; i < v.size(); ++i)
      os << ' ' << v[i];
  }
  return os;
}

template <class T>
struct Heap {
  priority_queue<T> q, d;

  void push(const T& x) {
    q.push(x);
  }

  T top() {
    while (!d.empty() && d.top() == q.top()) {
      d.pop();
      q.pop();
    }
    return q.top();
  }

  void pop() {
    while (!d.empty() && d.top() == q.top()) {
      d.pop();
      q.pop();
    }
    q.pop();
  }

  void del(const T& x) {
    d.push(x);
  }

  bool empty() {
    return q.size() == d.size();
  }
};

int main() {
#ifdef ELEGIA
  freopen("test.in", "r", stdin);
  int nol_cl = clock();
#endif
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  int T;
  cin >> T;
  while (T--) {
    int n, K, L;
    cin >> n >> K >> L;
    vector<int> a(n), b(n);
    vector<bool> visa(n), visb(n);
    cin >> a >> b;
    vector<pair<int, int>> pa(n), pb(n);
    for (int i = 0; i < n; ++i) {
      pa[i] = make_pair(a[i], i);
      pb[i] = make_pair(b[i], i);
    }
    sort(pa.begin(), pa.end(), greater<pair<int, int>>());
    sort(pb.begin(), pb.end(), greater<pair<int, int>>());
    ll ans = 0;
    for (int i = 0; i < K - L; ++i) {
      visa[pa[i].second] = true;
      visb[pb[i].second] = true;
      ans += pa[i].first;
      ans += pb[i].first;
    }
    /* we will do this "greedy"/"cost flow" with heap!
    vector<bool> fix(n);
    for (int rep = 0; rep < L; ++rep) {
      pair<int, int> ma(0, 0), mb(0, 0);
      for (int i = 0; i < n; ++i) {
        if (!visa[i]) ma = max(ma, make_pair(a[i], i));
        if (!visb[i]) mb = max(mb, make_pair(b[i], i));
      }
      pair<int, int> best(0, 0);
      for (int i = 0; i < n; ++i) {
        if (fix[i]) continue;
        int cur = 0;
        cur += visa[i] ? ma.first : a[i];
        cur += visb[i] ? mb.first : b[i];
        best = max(best, make_pair(cur, i));
      }
      ans += best.first;
      int j = best.second;
      fix[j] = true;
      if (!visa[j]) visa[j] = true;
      else visa[ma.second] = true;
      if (!visb[j]) visb[j] = true;
      else visb[mb.second] = true;
    }*/
    vector<Heap<pair<int, int>>> greed(4);
    vector<Heap<pair<int, int>>> extra(2);

    auto roll = [&](int i, bool f = true) {
      int state = visa[i] | (visb[i] << 1), cost = 0;
      if (!visa[i]) cost += a[i];
      if (!visb[i]) cost += b[i];
      if (f)
        greed[state].push(make_pair(cost, i));
      else
        greed[state].del(make_pair(cost, i));
    };

    for (int i = 0; i < n; ++i) {
      if (!visa[i])
        extra[0].push(make_pair(a[i], i));
      if (!visb[i])
        extra[1].push(make_pair(b[i], i));
      roll(i);
    }
    while (L--) {
      pair<int, int> dec(0, -1);
      for (int i = 0; i < 4; ++i) {
        if (greed[i].empty()) continue;
        auto cur = greed[i].top();
        if (i & 1) cur.first += extra[0].top().first;
        if (i & 2) cur.first += extra[1].top().first;
        dec = max(dec, cur);
      }
      ans += dec.first;
      int i = dec.second;
      int state = visa[i] | (visb[i] << 1);
      greed[state].pop();
      if (visa[i]) {
        int j = extra[0].top().second;
        extra[0].pop();
        roll(j, false);
        visa[j] = true;
        roll(j, true);
      } else {
        visa[i] = true;
        extra[0].del(make_pair(a[i], i));
      }
      if (visb[i]) {
        int j = extra[1].top().second;
        extra[1].pop();
        roll(j, false);
        visb[j] = true;
        roll(j, true);
      } else {
        visb[i] = true;
        extra[1].del(make_pair(b[i], i));
      }
    }
    cout << ans << '\n';
  }

#ifdef ELEGIA
  LOG("Time: %dms\n", int ((clock()
          -nol_cl) / (double)CLOCKS_PER_SEC * 1000));
#endif
  return 0;
}