#include <bits/stdc++.h>
#include <boost/range/algorithm.hpp>
#include <boost/range/numeric.hpp>
#include <boost/integer/common_factor.hpp>
#include <boost/integer/common_factor_rt.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>

using std::string;
using std::vector;
using std::set;
using std::multiset;
using std::unordered_set;
using std::map;
using std::multimap;
using std::unordered_map;
using std::pair;
using std::cin;
using std::cout;

using boost::multiprecision::cpp_int;
using cpp_dec_float_1000 = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<1000, boost::int128_type>>;

typedef uintmax_t    ull;
typedef intmax_t     ll;
typedef uint64_t     ul;
typedef uint32_t     ui;
typedef uint8_t      uc;

constexpr char CRLF  = '\n';
constexpr char SPACE = ' ';
constexpr char VECTOR_COUT_SEPARATOR = SPACE;
constexpr ll INF = 1000'000'007;
constexpr int MOD = 1000'000'007;

template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> std::ostream& operator<< (std::ostream& os, const std::vector<T>& vc) { for(auto it = vc.begin(); it != vc.end(); ++it) { if (std::next(it) == vc.end()) os << *it; else os << *it << VECTOR_COUT_SEPARATOR; } return os; }
template<class T1, class T2> inline std::ostream & operator<< (std::ostream & os, const std::pair<T1, T2> & p) { return os << p.first << ' ' << p.second; }
template<class T> T modinv(T a, T m) { T b = m, u = 1, v = 0; while (b) { T t = a / b; a -= t * b; boost::swap(a, b); u -= t * v; boost::swap(u, v); } u %= m; if (u < 0) u += m; return u; }
template<class T> inline bool isSosuu(const T& n) { if (n == T(1)) { return false; } for (T i = 2; i*i <= n; ++i) { if (n % i == 0) { return false; } } return true; }
template<class T> vector<vector<T>> split (const vector<T>& S, T delim) { vector<vector<T>> ret{}; vector<T> buff{}; for (auto c : S) { if (c == delim) { if (!buff.empty()) ret.push_back(buff); buff.clear(); } else { buff.push_back(c); } } if (!buff.empty()) ret.push_back(buff); return ret; }

struct Tmp
{
public:
  using Node = pair<ll, int>;
  int X, Y, A, B, C;
  ll inf = INF;
  vector<ll> P, Q, R;
  vector<ll> resultA, resultB;
  Tmp(int X, int Y, int A, int B, int C)
  : X(X), Y(Y)
  , A(A), B(B), C(C)
  , P(A), Q(B), R(C)
  , resultA(), resultB()
  {}

  ll operator() () {
    pre();
    ll res{};
    assert(resultA.size() == X);
    assert(resultB.size() == Y);
    for (const auto& r : resultA) {
      res += r;
    }
    for (const auto& r : resultB) {
      res += r;
    }
    return res;
  }

  void pre() {
    boost::sort(P, std::greater<ll>());
    boost::sort(Q, std::greater<ll>());
    boost::sort(R, std::greater<ll>());

    multiset<ll> setA{P.begin(), P.begin()+X};
    multiset<ll> setB{Q.begin(), Q.begin()+Y};

    int c_i = C - 1;
    while (c_i >= 0) {
      auto a = setA.begin();
      auto b = setB.begin();
      if (*a < R[c_i] && *b < R[c_i]) {
        if (*a < *b) {
          setA.erase(a);
          setA.emplace(R[c_i]);
        } else {
          setB.erase(b);
          setB.emplace(R[c_i]);
        }
      } else if (*a < R[c_i]) {
        setA.erase(a);
        setA.emplace(R[c_i]);
      } else if (*b < R[c_i]) {
        setB.erase(b);
        setB.emplace(R[c_i]);
      } else {
        ;
      }
      --c_i;
    }

    resultA = vector<ll>(setA.begin(), setA.end());
    resultB = vector<ll>(setB.begin(), setB.end());
  }
};

void solve(void)
{
  int X, Y; cin >> X >> Y;
  int A, B, C; cin >> A >> B >> C;
  Tmp t(X, Y, A, B, C);
  for (auto& p : t.P) {
    cin >> p;
  }
  for (auto& q : t.Q) {
    cin >> q;
  }
  for (auto& r : t.R) {
    cin >> r;
  }

  auto ans = t();
  cout << ans << CRLF;
  return;
}

int main(void)
{
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(0);

  solve();

  return 0;
}


Measured memory_bytes: 12416