#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define SPEED ios_base::sync_with_stdio(false); cin.tie(NULL);
#define FOR(i, a, b) for (ll i = a; i < b; ++i)
#define RFOR(i, b, a) for (ll i = b; i >= a; --i)
#define ALL(x) x.begin(), x.end()
#define DEBUG(args...) { string _s = #args; replace(ALL(_s), ' ', '\0');\
replace(ALL(_s), ',', ' ');\
stringstream _ss(_s); istream_iterator<string> _it(_ss); _debug(_it, args);}
#define endl "\n"
#define F first
#define S second
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)

using namespace std;
using namespace __gnu_pbds;

template<typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

void _debug(istream_iterator<string>) {}
template<typename T, typename... Args>
void _debug(istream_iterator<string> it, T first, Args... args) {
    cerr << ">> " << *it << " : " << first << endl; _debug(++it, args...);
}
template <typename T1, typename T2>
inline ostream& operator << (ostream& out, const pair<T1, T2>& p) {
    return out << "(" << p.F << ", " << p.S << ")";
}
template<typename T>
inline ostream& operator << (ostream& out, const vector<T>& v) {
    if (v.empty()) return out << "[]";
    else { out << '['; for (auto& e : v) { out << e << ", "; } return out << "\b\b]"; }
}
template<typename T>
inline ostream& operator << (ostream& out, const set<T>& s) {
    if (s.empty()) return out << "{}";
    else { out << '{'; for (auto& e : s) { out << e << ", "; } return out << "\b\b}"; }
}
template<typename T>
inline ostream& operator << (ostream& out, const unordered_set<T>& s) {
    return out << set<T>(ALL(s));
}
template<typename T1, typename T2>
inline ostream& operator << (ostream& out, const map<T1, T2>& m) {
    if (m.empty()) return out << "{}";
    out << '{'; for (auto& p : m) { out << p << ", "; } return out << "\b\b}";
}
template<typename T1, typename T2>
inline ostream& operator << (ostream& out, const unordered_map<T1, T2>& m) {
    return out << map<T1, T2>(ALL(m));
}
template<typename T>
inline ostream& operator << (ostream& out, const ordered_set<T>& s) {
    return out << set<T>(ALL(s));
}

typedef long long ll;
typedef long double ld;
typedef vector<long long> vll;
typedef pair<ll, ll> pll;
typedef vector<pair<ll, ll>> vpll;
typedef unordered_map<ll, ll> STll;
/************************************** MAIN PROGRAM ********************************************/
const ll INF = 1e18;
#define int ll
main()
{
    //freopen("input.txt", "r", stdin);
    SPEED
    int x, y;
    cin >> x >> y;
    int a, b, c;
    cin >> a >> b >> c;
    vector<ll> p(a), q(b), r(c);
    for (auto &e : p) {
        cin >> e;
    }
    for (auto &e : q) {
        cin >> e;
    }
    for (auto &e : r) {
        cin >> e;
    }
    sort(ALL(p), greater<>());
    sort(ALL(q), greater<>());
    sort(ALL(r), greater<>());
    vector<ll> prefq(b + 1), prefr(c + 1), prefp(a + 1);
    for (int i = 1; i <= b; ++i) {
        prefq[i] = prefq[i - 1] + q[i - 1];
    }
    for (int i = 1; i <= c; ++i) {
        prefr[i] = prefr[i - 1] + r[i - 1];
    }
    for (int i = 1; i <= a; ++i) {
        prefp[i] = prefp[i - 1] + p[i - 1];
    }

    ll alreadyredsum = accumulate(ALL(p), 0ll);
    int j = 0;
    ll maderedsum = 0;
    int ptrq = 0;
    int ptrr = 0;
    auto greens = [&]() {
        return ptrq + ptrr - j;
    };
    ll ans = 0;
    for (int i = a; i >= 0; --i) {
        int rneed = max(x - (i), 0ll);
        while (j < rneed && j < c) {
            //maderedsum += r[j];
            j++;
        }
        ptrr = max(j, ptrr);

        while (greens() < y) {
            ll optionr = ptrr == c ? -INF : r[ptrr];
            ll optionq = ptrq == b ? -INF : q[ptrq];
            ll best = max(optionq, optionr);
            if (best == -INF) break;
            if (best == optionq) {
                ptrq++;
            } else if (best == optionr) {
                ptrr++;
            }
        }
        int reds = i + j;
       // DEBUG(reds, greens(), ptrq, ptrr, j)
        if (reds == x && greens() == y) {
            ll res = prefp[i];
            res += prefq[ptrq];
            res += prefr[ptrr];
            ans = max(ans, res);
        }
    }
    cout << ans;
}
/************************************** END OF PROGRAM ******************************************/
/** Stuff you should look for:
 * int overflow, array bounds, over-counting
 * special cases (n=1?), set/unordered_set TLE, multi-set/set error
 * do something instead of nothing and stay organized
 */


Measured memory_bytes: 4992