#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <set>
#include <map>
#include <vector>
#include <string>

using namespace std;

#define LL long long

const int dx[4] = {1, -1, 0, 0};
const int dy[4] = {0, 0, 1, -1};

LL mod(LL x, LL md) {
	return ((x % md) + md) % md;
}

class Mint {
public:
	static LL md;
	LL x;
	Mint(LL _x) {
		x = mod(_x, md);
	}
	Mint(const Mint &y) {
		x = mod(y.x, md);
	}
};

void MintMyExgcd(LL a, LL b, LL &x, LL &y) {
	// solve equation ax + by = 1 (mod m)
	LL md = Mint::md;
	if (b == 0) {
		y = 0;
		x = 1;
		return ;
	}
	MintMyExgcd(b, a % b, x, y);
	LL t = y;
	y = mod(x - (a / b) * y, md);
	x = t;
}

LL MintNY(LL x) {
	if (x == 0) {
		return 1;
	}
	LL md = Mint::md;
	LL a, b;
	MintMyExgcd(x, md, a, b);
	while (a < 0) {
		a += md;
	}
	return a;
}

/* LL gcd(LL a, LL b) {
	if (b == 0) {
		return a;
	}
	return gcd(b, a % b);
} */

Mint operator+(Mint a, Mint b) {
	return Mint(mod(a.x + b.x, Mint::md));
}
Mint operator-(Mint a, Mint b) {
	return Mint(mod(a.x - b.x, Mint::md));
}
Mint operator*(Mint a, Mint b) {
	return Mint(mod(a.x * b.x, Mint::md));
}
Mint operator/(Mint a, Mint b) {
	Mint c = Mint(MintNY(b.x));
	return Mint(mod(a.x * c.x, Mint::md));
}

Mint operator-(Mint a) {
	return Mint(-a.x);
}
bool operator==(Mint a, Mint b) {
	return a.x == b.x;
}
bool operator!=(Mint a, Mint b) {
	return a.x != b.x;
}
bool operator>(Mint a, Mint b) {
	return a.x > b.x;
}
bool operator<(Mint a, Mint b) {
	return a.x < b.x;
}
bool operator>=(Mint a, Mint b) {
	return a.x >= b.x;
}
bool operator<=(Mint a, Mint b) {
	return a.x <= b.x;
}

void operator+=(Mint &a, Mint b) {
	a = a + b;
}
void operator-=(Mint &a, Mint b) {
	a = a - b;
}
void operator*=(Mint &a, Mint b) {
	a = a * b;
}
void operator/=(Mint &a, Mint b) {
	a = a / b;
}

ostream& operator<<(ostream &out, Mint a) {
	out << a.x;
	return out;
}

istream& operator>>(istream &in, Mint &a) {
	in >> a.x;
	return in;
}

Mint factorial(LL n) {
	if (n == 0) {
		return Mint(1);
	}
	Mint res = 1;
	for (LL i = 1; i <= n; ++i) {
		res *= i;
	}
	return res;
}
Mint multiRange(LL s, LL t) {
	Mint res = 1;
	for (LL i = s; i <= t; ++i) {
		res *= i;
	}
	return res;
}

Mint getC(LL n, LL k) {
	if (n - k < k) {
		return getC(n, n - k);
	}
	return multiRange(n - k + 1, n) / factorial(k);
}

Mint getA(LL n, LL k) {
	return multiRange(n - k + 1, n);
}

Mint countNonNegativeDivision(LL n, LL k) {
	return getC(n + k - 1, k - 1);
}
Mint countPositiveDivision(LL n, LL k) {
	if (n < k) {
		return 0;
	}
	if (k <= 0) {
		return 0;
	}
	return getC(n - 1, k - 1);
}
Mint quickMod(Mint a, LL b) {
	Mint res = 1;
	while (b > 0) {
		if (b % 2) {
			res *= a;
		}
		a *= a;
		b /= 2;
	}
	return res;
}

LL Mint::md = 1000000007;

int isKth(vector<int> &a, vector<int> &b, int k, int aIndex) {
	// +1 if greater than kth
	// -1 if lower than kth
	// 0 if just kth
	int aLeftN = aIndex;
	int bLeftN = k - aLeftN - 1;
	if (bLeftN < 0) {
		return 1;
	}
	if (bLeftN > b.size()) {
		return -1;
	}
	// if a is k-th, a >= b[bLeftN - 1], a <= b[bLeftN]
	if (bLeftN - 1 >= 0 && bLeftN - 1 < b.size() && a[aIndex] < b[bLeftN - 1]) {
		return -1;
	}
	if (bLeftN >= 0 && bLeftN < b.size() && a[aIndex] > b[bLeftN]) {
		return 1;
	}
	return 0;
}

bool getKthInA(vector<int> &a, vector<int> &b, int k, int &res) {
	int left = 0, right = a.size() - 1;
	int an = a.size(), bn = b.size();
	int mid = (left + right) / 2;
	while (left < right) {
		// printf("left = %d, right = %d\n", left, right);
		int midIsKth = isKth(a, b, k, mid);
		if (midIsKth == 1) {
			right = mid;
		}
		if (midIsKth == -1) {
			left = mid + 1;
		}
		if (midIsKth == 0) {
			res = a[mid];
			return true;
		}
		mid = (left + right) / 2;
	}
	mid = left; 
	int midIsKth = isKth(a, b, k, mid);
	res = a[mid];
	return (midIsKth == 0);
}
int getKth(vector<int> &a, vector<int> &b, int k) {
	int res = 0;
	bool flag = getKthInA(a, b, k, res);
	// cout << flag << ' ' << res << endl;
	if (flag) {
		// printf("%d-th in a, is %d\n", k, res);
		return res;
	}
	flag = getKthInA(b, a, k, res);
	if (flag) {
		// printf("%d-th in b, is %d\n", k, res);
		return res;
	}
	return -1;
}

int x, y, a, b, c;
vector<int> p, q, r;
int main() {
	scanf("%d%d%d%d%d", &x, &y, &a, &b, &c);
	int tmp;
	for (int i = 0; i < a; ++i) {
		scanf("%d", &tmp);
		p.push_back(tmp);
	}
	for (int i = 0; i < b; ++i) {
		scanf("%d", &tmp);
		q.push_back(tmp);
	}
	for (int i = 0; i < c; ++i) {
		scanf("%d", &tmp);
		r.push_back(tmp);
	}
	sort(p.begin(), p.end(), greater<int>());
	sort(q.begin(), q.end(), greater<int>());
	sort(r.begin(), r.end(), greater<int>());
	int pc = x - 1, qc = y - 1;
	LL ans = 0;
	int infd = 1000000001;
	for (int i = 0; i < x; ++i) {
		ans += p[i];
	}
	for (int i = 0; i < y; ++i) {
		ans += q[i];
	}
	for (int i = 0; i < c; ++i) {
		int cd = r[i];
		int ad = (pc >= 0) ? p[pc] : infd;
		int bd = (qc >= 0) ? q[qc] : infd;
		if (ad >= cd && bd >= cd) {
			break;
		}
		if (ad < bd) {
			ans += (cd - ad);
			--pc;
		}
		else {
			ans += (cd - bd);
			--qc;
		}
	}
	cout << ans << endl;
	return 0;
}

Measured memory_bytes: 1784