#include<bits/stdc++.h> 
using namespace std; 
vector<vector<int> > neighbours(200000);
int parent[200000];
pair<int,int> ways[200000];
int num_ways[200000];


vector<int> factorial;
vector<int> factorial_inv;
int mod;
void setmod(int x){
    	mod = x;
}
long long modu(long long p){
		return ((p%mod)+mod)%mod;
}
int modu(int p){
	return ((p%mod)+mod)%mod;
}
long long gcdExtended(int a, int b, long long *x, long long *y); 

	// Function to find modulo inverse of a 
int modInverse(int a) 
{ 
	    long long x, y; 
	    long long g = gcdExtended(a, mod, &x, &y); 
	    if (g != 1) 
	        return 1; 
	    else
	    { 
	        // m is added to handle negative x 
	        int res = (x%mod + mod) % mod; 
	        return  res; 
	    } 
} 
	  
	// C function for extended Euclidean Algorithm 
long long gcdExtended(int a, int b, long long *x, long long *y) 
{ 
	    // Base Case 
	    if (a == 0) 
	    { 
	        *x = 0, *y = 1; 
	        return (long long) b; 
	    } 
	  
	    long long x1, y1; // To store results of recursive call 
	    long long gcd = gcdExtended(b%a, a, &x1, &y1); 
	  
	    // Update x and y using results of recursive 
	    // call 
	    *x = y1 -  x1*(b/a); 
	    *y = x1; 
	  
	    return gcd; 
	} 


void create_fact(int x){
		factorial.resize(x+1);
		factorial[0] = 1;
		for(int j=1;j<=x;j++){
			factorial[j] = modu(1LL*factorial[j-1]*j);
		}
}
void create_fact_inv(int x){
		factorial_inv.resize(x+1);
		factorial_inv[0] = 1;
		for(int j=1;j<=x;j++){
			factorial_inv[j] = modInverse(1LL*factorial[j]);
		}
}
long long ncr(int p,int q){
		long long  x = modu(1LL*factorial[p]*factorial_inv[q]);
		long long  y = modu(x*factorial_inv[p-q]);
		return y;
}
int fact(int x){
	return factorial[x];
}
int fact_inv(int x){
	return factorial_inv[x];
}
//setmod(x)
//create_fact(x)
//create_fact_inv(x)
//fact(x)
//fact_inv(x);
//ncr
void dfs(int node){
	//cout<<"Node"<<endl;
	int num = 0;
	for(int j=0;j<neighbours[node].size();j++){
		if(neighbours[node][j]!=parent[node]){
			parent[neighbours[node][j]] = node;
			dfs(neighbours[node][j]);
			
			num = num + ways[neighbours[node][j]].first;
		}
	}
	long long s = 1;
	int chosen = 0;
	for(int j=0;j<neighbours[node].size();j++){
		if(neighbours[node][j]!=parent[node]){
			s = modu(modu(s * ways[neighbours[node][j]].second)*ncr(num - chosen,ways[neighbours[node][j]].first));
		    chosen = chosen+ ways[neighbours[node][j]].first;
		}
		
	}
	ways[node].second = (int) s;
	ways[node].first = num+1;
}

int main(){
	
	int X,Y,A,B,C;
	cin>>X>>Y>>A>>B>>C;
	vector<int> AC(A);
	vector<int> BC(B);
	vector<int> CC(C);
	vector<pair<int,int> > ABC(A+B+C);
	for(int j=0;j<A;j++){
		cin>>AC[j];
		ABC[j] = make_pair(AC[j],2);
	}
	for(int j=0;j<B;j++){
		cin>>BC[j];
		ABC[j+A] = make_pair(BC[j],1);
	}
	for(int j=0;j<C;j++){
		cin>>CC[j];
		ABC[j+A+B] = make_pair(CC[j],0);
	}
	sort(ABC.begin(),ABC.end());
	int a=0;
	int b =0;
	int c =0;
	for(int j =ABC.size()-1;j>ABC.size()-1-X-Y ;j--){
		if(ABC[j].second == 0){
			c++;
		}
		else if(ABC[j].second == 1)
			b++;
		else
			a++;
	}
	if(a>X){
		vector<int> BC1(B+C);
			for(int j=0;j<B;j++){
				BC1[j] = BC[j];
			}
			for(int j=0;j<C;j++){
				BC1[j+B] = CC[j];
			}
		sort(BC1.begin(),BC1.end());
		sort(AC.begin(),AC.end());
		long long s1 =0;
		for(int j =AC.size()-1;j>AC.size()-1-X;j--){
			s1=s1+AC[j];
		}
		for(int j =BC1.size()-1;j>BC1.size()-1-Y;j--){
			s1=s1+BC1[j];
		}
		cout<<s1<<endl;
	}
	else if (b>Y){
		vector<int> AC1(A+C);
			for(int j=0;j<A;j++){
				AC1[j] = AC[j];
			}
			for(int j=0;j<C;j++){
				AC1[j+A] = CC[j];
			}
		sort(AC1.begin(),AC1.end());
		sort(BC.begin(),BC.end());
		long long s1 =0;
		for(int j =BC.size()-1;j>BC.size()-1-Y;j--){
			s1=s1+BC[j];
		}
		for(int j =AC1.size()-1;j>AC1.size()-1-X;j--){
			s1=s1+AC1[j];
		}
		cout<<s1<<endl;
	}
	else{
		long long s1 =0;
		for(int j =ABC.size()-1;j>ABC.size()-1-X-Y ;j--){
			s1 = s1+ABC[j].first;
		}
		cout<<s1<<endl;	
	}
	return 0;
}


Measured memory_bytes: 9216