CodeEff/ECCO huggingface dataset:
# Original solution
X,Y,A,B,C=list(map(int,input().split()))
p=list(map(int,input().split()))
q=list(map(int,input().split()))
r=list(map(int,input().split()))
tmp=sorted(p)
P=tmp[::-1]
tmp=sorted(q)
Q=tmp[::-1]
tmp=sorted(r)
R=tmp[::-1]
ans=0
while(1):
	if X==0 and Y==0:
		print(ans)
		break
	elif X>0 and Y>0:
		tmp=max(P[0],Q[0],R[0])
		ans+=tmp
		if tmp==P[0]:
			P=P[1:]
			X-=1
		elif tmp==Q[0]:
			Q=Q[1:]
			Y-=1
		elif tmp==R[0]:
			if P[0]>=Q[0]:
				R=R[1:]
				Y-=1
			else:
				R=R[1:]
				X-=1
	elif X==0:
		tmp=max(Q[0],R[0])
		ans+=tmp
		if tmp==Q[0]:
			Q=Q[1:]
			Y-=1
		elif tmp==R[0]:
			R=R[1:]
			Y-=1
	elif Y==0:
		tmp=max(P[0],R[0])
		ans+=tmp
		if tmp==P[0]:
			P=P[1:]
			X-=1
		elif tmp==R[0]:
			R=R[1:]
			X-=1

# Optimized solution
X,Y,A,B,C=list(map(int,input().split()))
p=list(map(int,input().split()))
q=list(map(int,input().split()))
r=list(map(int,input().split()))
tmp=sorted(p)
P=tmp[::-1]
tmp=sorted(q)
Q=tmp[::-1]
tmp=sorted(r)
R=tmp[::-1]
tmp=P[:X]+Q[:Y]+R
tmp=sorted(tmp)
tmp=tmp[::-1]
ans=sum(tmp[:X+Y])
print(ans)
# Original solution
from heapq import heappush, heappop, heapify

x, y, a, b, c = list(map(int, input().split()))
p = list(map(int, input().split()))
q = list(map(int, input().split()))
r = list(map(int, input().split()))

p.sort(reverse=True)
q.sort(reverse=True)
r.sort(reverse=True)
# print(p)
# print(q)
# print(r)

ar = p[:x]
ag = q[:y]
heapify(ar)
heapify(ag)

for i in range(c):
    if r[i] > ar[0] and r[i] > ag[0]:
        if ar[0] < ag[0]:
            heappop(ar)
            heappush(ar, r[i])
        else:
            heappop(ag)
            heappush(ag, r[i])
    elif r[i] <= ar[0] and r[i] > ag[0]:
        heappop(ag)
        heappush(ag, r[i])
    elif r[i] > ar[0] and r[i] <= ag[0]:
        heappop(ar)
        heappush(ar, r[i])
    else:
        # r[i] <= ar[0] and r[i] <= ag[0]
        break

# print(ar)
# print(ag)
ans = sum(ar) + sum(ag)
print(ans)


# Optimized solution
x, y, a, b, c = list(map(int, input().split()))
p = list(map(int, input().split()))
q = list(map(int, input().split()))
r = list(map(int, input().split()))

p.sort(reverse=True)
q.sort(reverse=True)

r += p[:x]
r += q[:y]
r.sort(reverse=True)

ans = sum(r[:x + y])
print(ans)
# Original solution
X,Y,A,B,C=list(map(int,input().split()))
p=sorted(list(map(int,input().split())))[::-1][:X]
q=sorted(list(map(int,input().split())))[::-1][:Y]
r=sorted(list(map(int,input().split())))[::-1]
pq=sorted(p+q)
for R in r:
    for i in range(len(pq)):
        if pq[i]<R:
            pq[i]=R
            break
print((sum(pq)))

# Optimized solution
X,Y,A,B,C=list(map(int,input().split()))
p=sorted(list(map(int,input().split())))[::-1][:X]
q=sorted(list(map(int,input().split())))[::-1][:Y]
r=list(map(int,input().split()))
ans=sorted(p+q+r)[::-1][:X+Y]
print((sum(ans)))
# Original solution
def main():
    import bisect
    x,y,a,b,c = list(map(int,input().split()))
    p = sorted(list(map(int,input().split())))[-1*x:]
    q = sorted(list(map(int,input().split())))[-1*y:]
    r = sorted(list(map(int,input().split())),reverse=True)
    for i in range(c):
        if p[0]>=q[0]:
            if q[0]<r[i]:
                bisect.insort_left(q,r[i])
                q = q[1:]
            else:
                break
        else:
            if p[0]<r[i]:
                bisect.insort_right(p,r[i])
                p = p[1:]
    print((sum(p)+sum(q)))

    
if __name__ == "__main__":
    main()


# Optimized solution
def main():
    import bisect
    x,y,a,b,c = list(map(int,input().split()))
    p = sorted(list(map(int,input().split())))[-1*x:]
    q = sorted(list(map(int,input().split())))[-1*y:]
    r = sorted(list(map(int,input().split())))
    ans = p+q+r
    ans = sorted(ans,reverse=True)[0:x+y]
    print((sum(ans)))

    
if __name__ == "__main__":
    main()
# Original solution
x, y, a, b, c = [int(t) for t in input().split()]
p = [int(t) for t in input().split()]
q = [int(t) for t in input().split()]
r = [int(t) for t in input().split()]
s = []
for i in range(x):
    p_max = max(p)
    if r:
        r_max = max(r)
    else:
        r_max = 0
    if p_max >= r_max:
        s.append(p.pop(p.index(p_max)))
    else:
        s.append(r.pop(r.index(r_max)))
for i in range(y):
    q_max = max(q)
    if r:
        r_max = max(r)
    else:
        r_max = 0
    if q_max >= r_max:
        s.append(q.pop(q.index(q_max)))
    else:
        s.append(r.pop(r.index(r_max)))
        
print((sum(s)))

# Optimized solution
x, y, a, b, c = [int(t) for t in input().split()]
p = [int(t) for t in input().split()]
q = [int(t) for t in input().split()]
r = [int(t) for t in input().split()]

s = []
p.sort(reverse=True)
p = p[:x]

q.sort(reverse=True)
q = q[:y]

s = p + q + r
s.sort(reverse=True)
s = s[:x+y]
print((sum(s)))
# Original solution
#!/usr/bin/env python3
# -*- coding: utf-8 -*-*-

from sys import stdin


def main():
    X, Y, A, B, C = list(map(int, stdin.readline().split()))
    p = list(map(int, stdin.readline().split()))
    q = list(map(int, stdin.readline().split()))
    r = list(map(int, stdin.readline().split()))

    p.sort(reverse=True)
    q.sort(reverse=True)
    r.sort(reverse=True)

    oisisa = 0
    x, y, z = 0, 0, 0

    for i in range(0, X + Y):
        m_p = p[0] if len(p) > 0 else 0
        m_q = q[0] if len(q) > 0 else 0
        m_r = r[0] if len(r) > 0 else 0
        m = max( [m_p, m_q, m_r] )

        if m_p == m:
            # pから取る
            oisisa += p.pop(0)
            x += 1

        elif m_q == m:
            # qから取る
            oisisa += q.pop(0)
            y += 1
        else:
            # rから取る
            oisisa += r.pop(0)
            z += 1

        if x >= X:
            p = []
        if y >= Y:
            q = []

        if x + y + z == X + Y:
            print(oisisa)
            return


if __name__ == "__main__":
    main()


# Optimized solution
#!/usr/bin/env python3
# -*- coding: utf-8 -*-*-

from sys import stdin


def main():
    X, Y, A, B, C = list(map(int, stdin.readline().split()))
    p = list(map(int, stdin.readline().split()))
    q = list(map(int, stdin.readline().split()))
    r = list(map(int, stdin.readline().split()))

    p.sort(reverse=True)
    q.sort(reverse=True)
    r.sort(reverse=True)

    oisii = []
    oisii.extend(p[0:X])
    oisii.extend(q[0:Y])
    oisii.extend(r)
    oisii.sort(reverse=True)
    print(( sum( oisii[0:X+Y]) ))


if __name__ == "__main__":
    main()
# Original solution
import sys
input = sys.stdin.readline
sys.setrecursionlimit(100000000)
INF = 10 ** 10
MOD = 10 ** 9 + 7
from heapq import heapify,heappop,heappush
input = sys.stdin.readline

def main():
    x,y,a,b,c = list(map(int,input().split()))
    R = list(map(int,input().split()))
    G = list(map(int,input().split()))
    M = list(map(int,input().split()))
    i,j,k = 0,0,0
    R.sort(reverse = True)
    G.sort(reverse = True)
    M.sort(reverse = True)
    
    ans = 0
    while i < x and j < y and k < c and k + i + j < x + y:
        tmp = max(R[i],G[j],M[k])
        ans += tmp
        if tmp == R[i]:
            i += 1
        elif tmp == G[j]:
            j += 1
        else:
            k += 1
    
    if i + j + k == x + y:
        print(ans)
        return
    
    elif k == c:
        while i < x and j < y and i + j + c < x + y:
            tmp = max(R[i],G[j])
            ans += tmp
            if tmp == R[i]:
                i += 1
            elif tmp == G[j]:
                j += 1

    if i + j + k == x + y:
        print(ans)
        return            

    elif i == x:
        t = y - k - j
        for _ in range(t):
            if k < c and G[j] < M[k]:
                ans += M[k]
                k += 1
            else:
                ans += G[j]
                j += 1
    elif j == y:
        t = x - i - k
        for _ in range(t):
            if k < c and R[i] < M[k]:
                ans += M[k]
                k += 1
            else:
                ans += R[i]
                i += 1


    
    print(ans)

if __name__=='__main__':
    main()

# Optimized solution
import sys
input = sys.stdin.readline
sys.setrecursionlimit(100000000)
INF = 10 ** 10
MOD = 10 ** 9 + 7
from heapq import heapify,heappop,heappush
input = sys.stdin.readline

def main():
    x,y,a,b,c = list(map(int,input().split()))
    R = list(map(int,input().split()))
    G = list(map(int,input().split()))
    M = list(map(int,input().split()))
    R.sort(reverse = True)
    G.sort(reverse = True)
    M.sort(reverse = True)
    apple = R[:x] + G[:y] + M
    apple.sort(reverse = True)
    ans = sum(apple[:x + y])
    print(ans)
if __name__=='__main__':
    main()
# Original solution
def main():
    from collections import deque

    X, Y, A, B, C = list(map(int, input().split()))
    *p, = sorted(map(int, input().split()), reverse=True)
    *q, = sorted(map(int, input().split()), reverse=True)
    *r, = sorted(map(int, input().split()), reverse=True)

    p = deque(p[:X])
    q = deque(q[:Y])
    ret = sum(p) + sum(q)
    for x in r:
        if p:
            if q:
                if p[-1] < q[-1]:
                    if p[-1] >= x:
                        break
                    ret += x - p.pop()
                elif p[-1] == q[-1]:
                    popp = True
                    ofs = 1
                    while (1 + ofs) <= len(p) and (1 + ofs) <= len(q):
                        if p[-1 - ofs] == q[-1 - ofs]:
                            ofs += 1
                            continue

                        if p[-1 - ofs] < q[-1 - ofs]:
                            popp = True
                            break

                        if p[-1 - ofs] > q[-1 - ofs]:
                            popp = False
                            break
                    if popp:
                        if p[-1] >= x:
                            break
                        ret += x - p.pop()
                    else:
                        if q[-1] >= x:
                            break
                        ret += x - q.pop()
                else:
                    if q[-1] >= x:
                        break
                    ret += x - q.pop()

            else:
                if p[-1] >= x:
                    break
                ret += x - p.pop()
        else:
            if q:
                if q[-1] >= x:
                    break
                ret += x - q.pop()
            else:
                break

    print(ret)


if __name__ == '__main__':
    main()

# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())


# Optimized solution
def main():
    X, Y, A, B, C = list(map(int, input().split()))
    *p, = sorted(map(int, input().split()), reverse=True)
    *q, = sorted(map(int, input().split()), reverse=True)
    *r, = list(map(int, input().split()))

    pool = p[:X] + q[:Y] + r
    pool.sort(reverse=True)
    ret = sum(pool[:X + Y])
    print(ret)


if __name__ == '__main__':
    main()
# Original solution
x, y, a, b, c = list(map(int, input().split()))
*p, = list(map(int, input().split()))
*q, = list(map(int, input().split()))
*r, = list(map(int, input().split()))

p.sort(reverse=True)
q.sort(reverse=True)

pool = p[:x] + q[:y] + r
pool.sort(reverse=True)

pool = pool[:x + y]
ans = sum(pool)
print(ans)


# Optimized solution
def main():
    X, Y, A, B, C = list(map(int, input().split()))
    *P, = list(map(int, input().split()))
    *Q, = list(map(int, input().split()))
    *R, = list(map(int, input().split()))

    P.sort(reverse=True)
    Q.sort(reverse=True)

    ans = sum(sorted(P[:X] + Q[:Y] + R, reverse=True)[:X + Y])
    print(ans)


if __name__ == '__main__':
    main()
# Original solution
import heapq
x,y,a,b,c=list(map(int,input().split()))
p=list(map(int,input().split()))
q=list(map(int,input().split()))
r=list(map(int,input().split()))

ri=sorted(r)[::-1]

qi=q[::]
pi=p[::]
if x>a:
    pi+=ri[:x-a]
    ri=ri[x-a:]
if y>b:
    qi+=ri[:y-b]
    ri=ri[y-b:]

pi=sorted(pi)[::-1]
pi=pi[:x]
qi=sorted(qi)[::-1]
qi=qi[:y]
heapq.heapify(pi)
heapq.heapify(qi)

try:
    while pi[0]<ri[0] or qi[0]<ri[0]:
        if pi[0]<qi[0]:
            heapq.heappop(pi)
            heapq.heappush(pi,ri[0])
            ri.pop(0)
        else:
            heapq.heappop(qi)
            heapq.heappush(qi,ri[0])
            ri.pop(0)
except IndexError:
    ri=ri
print((sum(pi)+sum(qi)))


# Optimized solution
x,y,a,b,c=list(map(int,input().split()))
p=list(map(int,input().split()))
q=list(map(int,input().split()))
r=list(map(int,input().split()))

ri=sorted(r)[::-1]

qi=q[::]
pi=p[::]
pi=sorted(pi)[::-1]
pi=pi[:x]
qi=sorted(qi)[::-1]
qi=qi[:y]

l=pi+qi
l=sorted(l)
k=0
for i in range(min(c,x+y)):
    if l[i]>ri[i]:
        break
    else:
        k=i+1
print((sum(l[k:])+sum(ri[:k])))
# Original solution
x,y,a,b,c = list(map(int,input().split()))
p = list(map(int,input().split()))
q = list(map(int,input().split()))
r = list(map(int,input().split()))

p.sort(reverse=True)
q.sort(reverse=True)
r.sort(reverse=True)

p2 = p[:x]
q2 = q[:y]

for i in range(c):
  if p2[-1] <= q2[-1] and p2[-1] < r[i]:
    p2[-1] = r[i]
    p2.sort(reverse=True)
  if p2[-1] > q2[-1] and q2[-1] < r[i]:
    q2[-1] = r[i]
    q2.sort(reverse=True)
    
ans = sum(p2)+sum(q2)
print(ans)

# Optimized solution
x,y,a,b,c = list(map(int,input().split()))
p = list(map(int,input().split()))
q = list(map(int,input().split()))
r = list(map(int,input().split()))

p.sort(reverse=True)
q.sort(reverse=True)

p2 = p[:x]
q2 = q[:y]

l = p2 + q2 + r
l.sort(reverse=True)

ans = sum(l[:x+y])
print(ans)
# Original solution
X,Y,A,B,C = list(map(int,input().split()))

p = sorted(list(map(int,input().split()))) #A
q = sorted(list(map(int,input().split()))) #B
r = sorted(list(map(int,input().split()))) #C

xlist = p[-X:] #X
ylist = q[-Y:] #Y

def main(X,Y,xlist,ylist,r):
    for i in range(min(X,Y)):
        if xlist[i] < ylist[i] and min(xlist) < max(r):
            xlist.remove(min(xlist))
            xlist.append(max(r))
            r.pop()
        elif ylist[i] < xlist[i] and min(ylist) < max(r):
            ylist.remove(min(ylist))
            ylist.append(max(r))
            r.pop()
        elif min(xlist) >= max(r) and min(ylist) >= max(r):
            break
        else:
            continue
    
    print((sum(xlist)+sum(ylist)))

main(X,Y,xlist,ylist,r)

# Optimized solution
X,Y,A,B,C = list(map(int,input().split()))

p = sorted(list(map(int,input().split()))) #A
q = sorted(list(map(int,input().split()))) #B
r = sorted(list(map(int,input().split()))) #C

xlist = p[-X:] #X
ylist = q[-Y:] #Y

"""
def main(X,Y,xlist,ylist,r):
    for i in range(min(X,Y)):
        if xlist[i] < ylist[i] and min(xlist) < max(r):
            xlist.remove(min(xlist))
            xlist.append(r.pop())
            
        elif ylist[i] < xlist[i] and min(ylist) < max(r):
            ylist.remove(min(ylist))
            ylist.append(r.pop())
            
        elif min(xlist) >= max(r) and min(ylist) >= max(r):
            break
        else:
            continue
    
    print(sum(xlist + ylist))

main(X,Y,xlist,ylist,r)
"""
all_apples = sorted(xlist + ylist + r)
print((sum(all_apples[-(X+Y):])))
# Original solution
# coding: utf-8
X, Y, A, B, C = list(map(int, input().split()))
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
R = list(map(int, input().split()))
P.sort(reverse=True)
Q.sort(reverse=True)
R.sort(reverse=True)
ans = 0
L = P[:X] + Q[:Y]
L.sort()
idx = 0
for i in range(X+Y):
    if idx >= C:
        break
    if L[i] < R[idx]:
        L[i] = R[idx]
        idx += 1
print((sum(L)))

# Optimized solution
# coding: utf-8
X, Y, A, B, C = list(map(int, input().split()))
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
R = list(map(int, input().split()))
P.sort(reverse=True)
Q.sort(reverse=True)
R.sort(reverse=False)
ans = 0
L = P[:X] + Q[:Y] + R
L.sort(reverse=True)
print((sum(L[:X+Y])))
# Original solution
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    x,y,a,b,c = LI()
    p = LI()
    q = LI()
    r = LI()
    s = [(i,0) for i in p]+[(i,1) for i in q]+[(i,2) for i in r]
    s.sort(reverse = True)
    ans = 0
    f = [0,0]
    l = [x,y]
    q = deque()
    q2 = deque()
    for a,i in s:
        if i > 1:
            q.append(a)
        else:
            if f[i] < l[i]:
                ans += a
                f[i] += 1
                q2.append(a)
    s = ans
    while q and q2:
        s -= q2.pop()
        s += q.popleft()
        if ans < s:
            ans = s
    print(ans)
    return

#Solve
if __name__ == "__main__":
    solve()


# Optimized solution
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    x,y,a,b,c = LI()
    p = LI()
    q = LI()
    r = LI()
    p.sort(reverse = True)
    q.sort(reverse = True)
    s = p[:x]+q[:y]+r
    s.sort(reverse = True)
    print((sum(s[:x+y])))
    return

#Solve
if __name__ == "__main__":
    solve()
# Original solution
# -*- coding: utf-8 -*-

import sys
from heapq import heapify, heappop, heappush

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

X, Y, N, M, L = MAP()
A = LIST()
B = LIST()
C = LIST()

A.sort(reverse=1)
B.sort(reverse=1)
C.sort(reverse=1)

que = []
que += A[:X]
que += B[:Y]
heapify(que)

for c in C:
    mn = heappop(que)
    if c > mn:
        heappush(que, c)
    else:
        heappush(que, mn)
ans = sum(que)
print(ans)


# Optimized solution
# -*- coding: utf-8 -*-

import sys
from heapq import heapify, heappop, heappush

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

X, Y, N, M, L = MAP()
A = LIST()
B = LIST()
C = LIST()

A.sort(reverse=1)
B.sort(reverse=1)

que = []
que += A[:X]
que += B[:Y]
heapify(que)

for c in C:
    if c > que[0]:
        heappop(que)
        heappush(que, c)
ans = sum(que)
print(ans)
# Original solution
X, Y, A, B, C = list(map(int, input().split(' ')))

apples = []
for p in map(int, input().split(' ')):
    apples.append((p, 0))

for q in map(int, input().split(' ')):
    apples.append((q, 1))

for r in map(int, input().split(' ')):
    apples.append((r, 2))

apples.sort(reverse=True)

pq = []
r = []
x = X
y = Y

for d, t in apples:
    if t == 0:
        if x > 0:
            x -= 1
            pq.append(d)
        else:
            continue
    elif t == 1:
        if y > 0:
            y -= 1
            pq.append(d)
        else:
            continue
    else:
        r.append(d)

pq_len = len(pq)
for i in range(len(r)):
    if i >= pq_len:
        break

    if r[i] <= pq[-(i + 1)]:
        break

    pq[-(i + 1)] = r[i]

print((sum(pq)))


# Optimized solution
X, Y, A, B, C = list(map(int, input().split(' ')))

P = sorted(list(map(int, input().split(' '))), reverse=True)[:X]
Q = sorted(list(map(int, input().split(' '))), reverse=True)[:Y]
R = sorted(list(map(int, input().split(' '))), reverse=True)

apples = sorted(P + Q + R, reverse=True)[:X + Y]

print((sum(apples)))
# Original solution
X,Y,A,B,C = list(map(int,input().split()))
p = list(map(int,input().split()))
q = list(map(int,input().split()))
r = list(map(int,input().split()))
p = sorted(p)
q = sorted(q)
r = sorted(r)
P = A - X
Q = B - Y
R = C - 1
found = True
while R >= 0:
    if P < A:
        if (r[R] >= p[P]):
            if (q[Q] >= p[P]):
                P += 1
                R -= 1
        elif Q < B:
            if (r[R] > q[Q]):
                Q += 1
                R -= 1
            else:
                break
    elif Q < B:
        if (r[R] > q[Q]):
                Q += 1
                R -= 1
        else:
            break    
    else:
        break
print((sum(p[P:])+sum(q[Q:])+sum(r[R+1:])))

# Optimized solution
X,Y,A,B,C = list(map(int,input().split()))
p = list(map(int,input().split()))
q = list(map(int,input().split()))
r = list(map(int,input().split()))
p = sorted(p)
q = sorted(q)
r = sorted(r)
P = A - X
Q = B - Y
R = C - 1
found = True
for i in range(C+1):
    if R < 0:
        break
    if P < A:
        if (r[C-i-1] >= p[P]):
            if Q < B:
                if (q[Q] >= p[P]):
                    P += 1
                    R -= 1
                elif r[C-i-1] > q[Q]:
                    Q += 1
                    R -= 1
                else:
                    break
            else:
                P += 1
                R -= 1
        elif Q < B:
            if r[C-i-1] > q[Q]:
                Q += 1
                R -= 1
            else:
                break
        else:
            break
    elif Q < B:
        if r[C-i-1] > q[Q]:
            Q += 1
            R -= 1
        else:
            break    
    else:
        break
print((sum(p[P:])+sum(q[Q:])+sum(r[R+1:])))
# Original solution
x, y, a, b, c = list(map(int, input().split()))
arrayP = list(map(int, input().split()))
arrayQ = list(map(int, input().split()))
arrayR = list(map(int, input().split()))
arrayP.sort(reverse=True)
arrayQ.sort(reverse=True)
arrayR.sort(reverse=True)
arrayAns = []
for i in range(x):
    arrayAns.append(int(arrayP[i]))
for i in range(y):
    arrayAns.append(int(arrayQ[i]))
arrayAns.sort()
for i in range(len(arrayR)):
    if arrayAns[0] <= int(arrayR[i]):
        arrayAns[0] = int(arrayR[i])
        arrayAns.sort()
    else:
        break
print((sum(arrayAns)))


# Optimized solution
x, y, a, b, c = list(map(int, input().split()))
arrayP = list(map(int, input().split()))
arrayQ = list(map(int, input().split()))
arrayR = list(map(int, input().split()))
arrayP.sort(reverse=True)
arrayQ.sort(reverse=True)
arrayR.sort(reverse=True)
arrayAns = []
for i in range(x):
    arrayAns.append(int(arrayP[i]))
for i in range(y):
    arrayAns.append(int(arrayQ[i]))
arrayAns.sort()
for i in range(min(len(arrayR), len(arrayAns))):
    if arrayAns[i] <= int(arrayR[i]):
        arrayAns[i] = int(arrayR[i])
    else:
        break
print((sum(arrayAns)))