using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

static class Program
{
    class PriorityQueue<T>
    {
        private readonly List<T> m_list;
        private readonly Comparison<T> m_compare;
        public int Count { get; private set; }
        public PriorityQueue(Comparison<T> compare)
        {
            m_list = new List<T>();
            m_compare = compare;
            Count = 0;
        }
        private int Add(T value)
        {
            if (Count == m_list.Count)
            {
                m_list.Add(value);
            }
            else
            {
                m_list[Count] = value;
            }
            return Count++;
        }
        private void Swap(int a, int b)
        {
            T tmp = m_list[a];
            m_list[a] = m_list[b];
            m_list[b] = tmp;
        }
        public void Enqueue(T value)
        {
            int c = Add(value);
            while (c > 0)
            {
                int p = (c - 1) / 2;
                if (m_compare(m_list[c], m_list[p]) < 0) { Swap(p, c); } else { break; }
                c = p;
            }
        }
        public T Dequeue()
        {
            T value = m_list[0];
            m_list[0] = m_list[--Count];
            int p = 0;
            while (true)
            {
                int c1 = p * 2 + 1;
                int c2 = p * 2 + 2;
                if (c1 >= Count) { break; }
                int c = (c2 >= Count || m_compare(m_list[c1], m_list[c2]) < 0) ? c1 : c2;
                if (m_compare(m_list[c], m_list[p]) < 0) { Swap(p, c); } else { break; }
                p = c;
            }
            return value;
        }
    }

    static long Solve(int X, int Y, int A, int B, int C, long[] P, long[] Q, long[] R)
    {
        var reds = new PriorityQueue<long>((a, b) => a.CompareTo(b));
        var greens = new PriorityQueue<long>((a, b) => a.CompareTo(b));
        foreach (long p in P) { reds.Enqueue(p); }
        foreach (long q in Q) { greens.Enqueue(q); }
        while (reds.Count > X) { reds.Dequeue(); }
        while (greens.Count > Y) { greens.Dequeue(); }
        Array.Sort(R, (a, b) => b.CompareTo(a));
        foreach (long white in R)
        {
            long red = reds.Dequeue();
            long green = greens.Dequeue();
            if (red < green)
            {
                greens.Enqueue(green);
                if (white > red)
                {
                    reds.Enqueue(white);
                }
                else
                {
                    reds.Enqueue(red);
                    break;
                }
            }
            else
            {
                reds.Enqueue(red);
                if (white > green)
                {
                    greens.Enqueue(white);
                }
                else
                {
                    greens.Enqueue(green);
                    break;
                }
            }
        }
        long sum = 0;
        while (reds.Count > 0) { sum += reds.Dequeue(); }
        while (greens.Count > 0) { sum += greens.Dequeue(); }
        return sum;
    }

    static void Main(string[] args)
    {
        var V = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
        var P = Array.ConvertAll(Console.ReadLine().Split(), long.Parse);
        var Q = Array.ConvertAll(Console.ReadLine().Split(), long.Parse);
        var R = Array.ConvertAll(Console.ReadLine().Split(), long.Parse);
        Console.WriteLine(Solve(V[0], V[1], V[2], V[3], V[4], P, Q, R));
    }
}


Measured memory_bytes: 42296