using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Numerics;
using System.IO;
using System.Runtime.InteropServices;
using static System.Math;
using static Math2;
using static io;
using static utils;
using MethodImplAttribute = System.Runtime.CompilerServices.MethodImplAttribute;
using MethodImplOptions = System.Runtime.CompilerServices.MethodImplOptions;

class Program
{
    static void Main(string[] args)
    {
        var wrong_answer = new wrong_answer();
        wrong_answer.Solve();
    }
}

public class wrong_answer
{
    const int INF = 1 << 29;
    const long INFL = 1L << 60;
    const int MOD = 1000000007;
    const int MOD2 = 998244353;



    public void Solve()
    {
        var o = intm;
        var x = o[0];
        var y = o[1];
        var a = intm;
        var b = intm;
        var c = intm;

        Array.Sort(a);
        Array.Sort(b);
        Array.Sort(c);
        a.Reverse();
        b.Reverse();
        c.Reverse();

        long ans = 0;
        var pq = new PriorityQueue<Tuple<int, int>>((xx, yy) => xx.Item1 - yy.Item1);
        for (int i = 0; i < a.Length; ++i) pq.Push(new Tuple<int, int>(a[i], 0));
        for (int i = 0; i < b.Length; ++i) pq.Push(new Tuple<int, int>(b[i], 1));
        for (int i = 0; i < c.Length; ++i) pq.Push(new Tuple<int, int>(c[i], 2));

        int cco = 0;
        while (true)
        {
            if (x + y - cco <= 0) break;
            var xx = pq.Pop();
            if (xx.Item2 == 0 && x == 0) continue;
            else if (xx.Item2 == 1 && y == 0) continue;

            if (xx.Item2 == 0) x--;
            else if (xx.Item2 == 1) y--;
            else cco++;

            ans += xx.Item1;
        }
        write(ans);
    }




}

// the greatest element pops
class PriorityQueue<T>
{
    List<T> buf;
    public bool rev = false;
    Func<int, int, int> cmp;
    public PriorityQueue()
    {
        buf = new List<T>();
        cmp = (i, j) => Comparer<T>.Default.Compare(buf[i], buf[j]) * (rev ? -1 : 1);
    }
    public PriorityQueue(Func<T, T, int> cmp)
    {
        buf = new List<T>();
        this.cmp = (i, j) => cmp(buf[i], buf[j]);
    }
    void swap(int i, int j) { var t = buf[i]; buf[i] = buf[j]; buf[j] = t; }
    public void Push(T elem)
    {
        int n = buf.Count;
        buf.Add(elem);
        while (n > 0)
        {
            int i = (n - 1) >> 1;
            if (cmp(n, i) <= 0) break;
            swap(i, n);
            n = i;
        }
    }
    public T Pop()
    {
        T ret = buf[0];
        int n = buf.Count - 1;
        buf[0] = buf[n];
        buf.RemoveAt(n);
        for (int i = 0, j; (j = (i << 1) | 1) < n; i = j)
        {
            if (j != n - 1 && cmp(j, j + 1) < 0) ++j;
            if (cmp(i, j) < 0) swap(i, j);
            else break;
        }
        return ret;
    }
    public T Top => buf[0];
    public int Count => buf.Count;
}

public static class utils
{
    public static void swap<T>(ref T a, ref T b)
    {
        T x = a;
        a = b;
        b = x;
    }
    public static int digitsum(int n)
    {
        string s = n.ToString();
        int ret = 0;
        for (int i = 0; i < s.Length; ++i) ret += s[i] - '0';
        return ret;
    }
    public static int[] zaaku(long[] a)
    {
        var dic = new Dictionary<long, int>();
        long[] ar = new long[a.Length];
        a.CopyTo(ar, 0);
        Array.Sort(ar);
        int z = 0;
        foreach (var x in ar)
        {
            if (!dic.ContainsKey(x))
                dic[x] = z++;
        }
        return a.Select(c => dic[c]).ToArray();
    }

    public static int[] getranking(long[] A)
    {
        var dic = new Dictionary<long, int>();
        A.OrderByDescending(_ => _).Where(w => !dic.ContainsKey(w)).Select((x, i) => dic[x] = i + 1).ToList();
        return A.Select(i => dic[i]).ToArray();
    }
    public static List<Tuple<T, int>> compress<T>(T[] A) where T : IComparable
    {
        int i = 0;
        var ret = new List<Tuple<T, int>>();
        while (i < A.Length)
        {
            T x = A[i];
            int num = 0;
            while (i < A.Length && x.CompareTo(A[i]) == 0)
            {
                num++;
                i++;
            }
            ret.Add(new Tuple<T, int>(x, num));
        }
        return ret;
    }
}

public static class Math2
{
    public static long pow(long i, long n, long MOD = 1000000007)
    {
        long res = 1;
        while (n > 0)
        {
            if ((n & 1) != 0) res = res * i % MOD;
            i = i * i % MOD;
            n >>= 1;
        }
        return res;
    }
    public static int pow(int i, int n, int MOD = 1000000007)
    {
        int res = 1;
        while (n > 0)
        {
            if ((n & 1) != 0) res = res * i % MOD;
            i = i * i % MOD;
            n >>= 1;
        }
        return res;
    }

    public static long gcd(long i, long y)
    {
        while (y != 0)
        {
            var r = i % y;
            i = y;
            y = r;
        }
        return i;
    }
    public static long comb(long n, long r, int MOD = 1000000007)
    {
        long ret = 1;
        long x = 1;
        for (long i = n; i >= n - r + 1; --i)
        {
            ret = ret / x * i;
            ret %= MOD;
            x++;
        }
        return ret;
    }

    public static long lcm(long i, long y)
    {
        return i * y / gcd(i, y);
    }


    public static Dictionary<long, int> primefactorization(long N)
    {

        var ret = new Dictionary<long, int>();

        for (long i = 2; i * i <= N; ++i)
        {
            int cnt = 0;
            while (N % i == 0)
            {
                cnt++;
                N /= i;
            }
            if (cnt != 0) ret[i] = cnt;

        }
        if (N >= 2) ret[N] = 1;

        return ret;

    }

    public static List<long> divisorenumrate(long N)
    {
        var ret = new List<long>();

        for (long i = 1; i * i <= N; ++i)
        {

            if (N % i == 0)
            {
                ret.Add(i);
                ret.Add(N / i);
            }

        }

        return ret;

    }

    public static void swap<T>(ref T a, ref T b)
    {
        var i = a;
        a = b;
        b = i;
    }
    public static void chmin<T>(ref T a, T b) where T : IComparable
    {
        if (a.CompareTo(b) > 0) a = b;
    }
    public static void chmax<T>(ref T a, T b) where T : IComparable
    {
        if (a.CompareTo(b) < 0) a = b;
    }

}

public static class io
{
    //in
    public static string str => Console.ReadLine();

    public static string[] strm => str.Split(' ');

    public static long[] longm => strm.Select(long.Parse).ToArray();
    public static int[] intm => strm.Select(int.Parse).ToArray();
    public static char[] charm => str.ToArray();
    public static double[] doublem => strm.Select(double.Parse).ToArray();
    public static long long1 => longm[0];
    public static int int1 => intm[0];
    public static char char1 => charm[0];
    public static double double1 => doublem[0];
    public static long[] horizontalread(int N) { long[] A = new long[N]; for (int i = 0; i < N; ++i) A[i] = long1; return A; }
    public static void write(string a) => Console.WriteLine(a);
    public static void write(params object[] i) => write(string.Join(" ", i));
    public static void write<T>(IEnumerable<T> a) => write(string.Join(" ", a));
    public static void horizontalwrite<T>(IEnumerable<T> a) { foreach (var z in a) write(z); }
    public static void yn(bool i) { if (i) write("Yes"); else write("No"); }

}


Measured memory_bytes: 38448