using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using static System.Math;

namespace CsharpSpiral {
    partial class Program {
        static void Main(string[] args) {
            var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            Console.SetOut(sw);
            new Program().Solve(new ConsoleInput(Console.In, ' '));
            Console.Out.Flush();
        }
		public void Solve(ConsoleInput cin) {
			var line = cin.ReadIntArray(5);
			int X = line[0], Y = line[1], A = line[2], B = line[3], C = line[4];
			var P = cin.ReadLongArray(A);
			var Q = cin.ReadLongArray(B);
			var R = cin.ReadLongArray(C);
			HeapSort(P, true);
			HeapSort(Q, true);
			HeapSort(R, false);
			P = P.Skip(A-X).ToArray();
			Q = Q.Skip(B-Y).ToArray();
			long initial = P.Sum() + Q.Sum();
			long[] replace = new long[C + 1];
			var px = 0;var qy = 0;
			//px+qy+1==i
			for(int i = 1; i <= C; i++) {
				if(px >= X && qy >= Y) break;
				if(px >= X) {
					replace[i] = replace[i - 1] + R[i - 1] - Q[qy];
					qy++;
				} else if(qy >= Y) {
					replace[i] = replace[i - 1] + R[i - 1] - P[px];
					px++;
				} else {
					if(P[px] < Q[qy]) {
						replace[i] = replace[i - 1] + R[i - 1] - P[px];
						px++;
					} else {
						replace[i] = replace[i - 1] + R[i - 1] - Q[qy];
						qy++;
					}
				}
			}
			Console.WriteLine(replace.Max() + initial);
		}
		public static void HeapSort<T>(T[] A, bool Ascending) where T : IComparable<T> {
			var PQ = new PriorityQueue<T>(Ascending);
			PQ.Push(A);
			for(int i = PQ.length - 1; i >= 0; i--) {
				A[i] = PQ.Pop();
			}
		}
	}

	static class ExtendClass {
        public static string Join<T>(this IEnumerable<T> X, string separator = " ") => string.Join(separator, X);
    }

    class ConsoleInput {
        private readonly TextReader _stream;
        private readonly char _separator = ' ';
        private readonly Queue<string> inputStream;
        public ConsoleInput(TextReader stream, char separator = ' ') {
            this._separator = separator;
            this._stream = stream;
            inputStream = new Queue<string>();
        }
        public string Read {
            get {
                if(inputStream.Count != 0) return inputStream.Dequeue();
                string[] tmp = _stream.ReadLine().Split(_separator);
                for(int i = 0; i < tmp.Length; ++i)
                    inputStream.Enqueue(tmp[i]);
                return inputStream.Dequeue();
            }
        }
        public string ReadLine { get { return _stream.ReadLine(); } }
        public int ReadInt { get { return int.Parse(Read); } }
        public long ReadLong { get { return long.Parse(Read); } }
        public double ReadDouble { get { return double.Parse(Read); } }
        public string[] ReadStrArray(long N) {
            var ret = new string[N];
            for(long i = 0; i < N; ++i)
                ret[i] = Read;
            return ret;
        }
        public int[] ReadIntArray(long N) { var ret = new int[N]; for(long i = 0; i < N; ++i) ret[i] = ReadInt; return ret; }
        public long[] ReadLongArray(long N) { var ret = new long[N]; for(long i = 0; i < N; ++i) ret[i] = ReadLong; return ret; }
        public double[] ReadDoubleArray(long N) { var ret = new double[N]; for(long i = 0; i < N; ++i) ret[i] = ReadDouble; return ret; }
    }

	class PriorityQueue<T> where T : IComparable<T> {
		protected readonly List<T> body = new List<T>();
		protected Comparer<T> comparer { get; set; }
		public PriorityQueue(bool maxTop = true) {
			comparer
			= maxTop ? Comparer<T>.Create((T i, T j) => i.CompareTo(j))
			: Comparer<T>.Create((T i, T j) => j.CompareTo(i));
		}
		public PriorityQueue(Comparer<T> mComparer) { comparer = mComparer; }
		//suppose Me>Her if isRootMaximum
		protected int Compare(T Me, T Her) => comparer.Compare(Me, Her);
		protected int Compare(int x, int y) => Compare(body[x], body[y]);
		protected virtual void Swap(int x, int y) { T tmp = body[x]; body[x] = body[y]; body[y] = tmp; }
		public virtual void Push(T elem) {
			body.Add(elem);
			//the parent of n-th element is the ((n+1)>>1)-1-th
			UpHeap(lastIndex);
		}
		public void Push(IEnumerable<T> seq) {
			foreach(var item in seq) {
				Push(item);
			}
		}
		protected int UpHeap(int j) {
			while(j > 0) {
				int parent = ((j + 1) >> 1) - 1;
				if(Compare(parent, j) < 0) {
					Swap(parent, j);
				} else break;
				j = parent;
			}
			return j;
		}
		public virtual T Pop() {
			T top = body[0];
			Swap(0, lastIndex);
			body.RemoveAt(lastIndex);
			DownHeap(0);
			return top;
		}
		protected int DownHeap(int j) {
			while(j < length) {
				var leftChild = ((j + 1) << 1) - 1;
				if(leftChild >= length) break;
				var toSwap = leftChild;
				var rightChild = leftChild + 1;
				if(rightChild < length && Compare(leftChild, rightChild) < 0)
					toSwap = rightChild;
				if(Compare(j, toSwap) < 0) {
					Swap(toSwap, j);
				} else break;
				j = toSwap;
			}
			return j;
		}
		public T Top { get { return body[0]; } }
		public int length { get { return body.Count(); } }
		protected int lastIndex { get { return body.Count() - 1; } }
		public bool Any() => body.Any();
		public string Emit() { return body.ToArray().Join(","); }
	}
}


Measured memory_bytes: 37256