using System;
using System.Text;
using System.Collections.Generic;
using static System.Math;
using System.Linq;
using static System.Array;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;

namespace AtcoderExpress
{


    class Program2
    {
        static long mod = 1000000007;
        static void Main(string[] args)
        {
            var XYABC = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
            var X = XYABC[0];
            var Y = XYABC[1];
            var A = XYABC[2];
            var B = XYABC[3];
            var C = XYABC[4];
            long ans = 0;

            var red = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
            var gre = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
            var thr = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();

            var redpq = new PriorityQueue<long>(A,true);
            var ate = new PriorityQueue<long>(X+Y, false);
            for (long i = 0; i < A; i++)
            {
                redpq.Enqueue(red[i]);
            }

            for (long i = 0; redpq.Count > 0 && i < X; i++)
            {
                var tmp = redpq.Dequeue();
                
                ans += tmp;
                ate.Enqueue(tmp);

            }
            //Console.WriteLine(ans);
            var grepq = new PriorityQueue<long>(B, true);
            for (long i = 0; i < B; i++)
            {
                grepq.Enqueue(gre[i]);
            }

            for (long i = 0; grepq.Count > 0 && i < Y; i++)
            {
                var tmp = grepq.Dequeue();
                //Console.WriteLine(tmp);
                ans += tmp;
                ate.Enqueue(tmp);

            }

            var thrpq = new PriorityQueue<long>(C, true);
            for (long i = 0; i < C; i++)
            {
                thrpq.Enqueue(thr[i]);
            }

            while (thrpq.Count > 0)
            {
                long atemin = ate.Dequeue();
                ate.Enqueue(atemin);
                long thrmax = thrpq.Dequeue();

                    if(atemin < thrmax)
                    {
                        ans += thrmax - atemin;
                    ate.Dequeue();
                    }
                    else
                    {
                        break;
                    }
            }

            Console.WriteLine(ans);
            
        }
    }

    class PriorityQueue<T> where T : IComparable<T>
    {
        public readonly T[] Array;
        public readonly bool Greater;
        public long Count { get; private set; } = 0;

        public PriorityQueue(long capacity, bool greater = true)
        {
            this.Array = new T[capacity];
            this.Greater = greater;
        }

        public void Enqueue(T item)
        {
            this.Array[this.Count] = item;
            this.Count += 1;
            this.UpHeap();
        }

        public T Dequeue()
        {
            // 先頭要素を末尾にして再構成
            this.Swap(0, this.Count - 1);
            this.Count -= 1;
            this.DownHeap();

            return this.Array[this.Count];
        }

        public T Top()
        {
            return this.Array[this.Count-1];
        }

        private void UpHeap()
        {
            var n = this.Count - 1;
            while (n != 0)
            {
                // 親要素の座標
                var parent = (n - 1) / 2;

                if (this.Compare(this.Array[n], this.Array[parent]) > 0)
                {
                    this.Swap(n, parent);
                    n = parent;
                }
                else
                {
                    break;
                }
            }
        }

        private void DownHeap()
        {
            var parent = 0;
            while (true)
            {
                var child = 2 * parent + 1;
                if (child > this.Count - 1) break;

                if (child < this.Count - 1 && this.Compare(this.Array[child], this.Array[child + 1]) < 0)
                {
                    // 左より右の子のほうが大きい値の場合、右を入れ替え対象にする
                    child += 1;
                }

                if (this.Compare(this.Array[parent], this.Array[child]) < 0)
                {
                    this.Swap(parent, child);
                    parent = child;
                }
                else
                {
                    break;
                }
            }
        }

        private long Compare(T a, T b)
        {
            var c = a.CompareTo(b);
            if (!this.Greater)
            {
                c = -c;
            }
            return c;
        }

        private void Swap(long a, long b)
        {
            var tmp = this.Array[a];
            this.Array[a] = this.Array[b];
            this.Array[b] = tmp;
        }
    }
}


Measured memory_bytes: 43720