from collections import defaultdict, deque, Counter
import copy
from itertools import combinations, permutations, product, accumulate, groupby, chain
from heapq import heapify, heappop, heappush
import math
import bisect
from pprint import pprint
from random import randint
import sys
# sys.setrecursionlimit(700000)
input = lambda: sys.stdin.readline().rstrip('\n')
inf = float('inf')
mod1 = 10**9+7
mod2 = 998244353
def ceil_div(x, y): return -(-x//y)

#################################################

class f(object):
    def __init__(self, x):
        sc = SC[x]
        self.val = sa*j + sb*x + sc*i
    def __eq__(self, other):
        if not isinstance(other, f):
            return NotImplemented
        return self.val == other.val
    def __lt__(self, other):
        if not isinstance(other, f):
            return NotImplemented
        return self.val < other.val
    def __ne__(self, other):
        return not self.__eq__(other)
    def __le__(self, other):
        return self.__lt__(other) or self.__eq__(other)
    def __gt__(self, other):
        return not self.__le__(other)
    def __ge__(self, other):
        return not self.__lt__(other)

def findMin(f, l, r):
    while r-l >= 3:
        c1 = l+(r-l)//3
        c2 = r-(r-l)//3
        if f(c1) < f(c2): r = c2
        else: l = c1
    return min(list(range(l, r+1)), key=lambda k: f(k))

def findMax(f, l, r):
    while r-l >= 3:
        c1 = l+(r-l)//3
        c2 = r-(r-l)//3
        if f(c1) > f(c2): r = c2
        else: l = c1
    return max(list(range(l, r+1)), key=lambda k: f(k))


NA, NB, NC = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)

a, b, c = 0, 0, 0
while a < NA and A[a] >= 0:
    a += 1
while b < NB and B[b] >= 0:
    b += 1
while c < NC and C[c] >= 0:
    c += 1

SA = [0]+list(accumulate(A))
SB = [0]+list(accumulate(B))
SC = [0]+list(accumulate(C))

ans = 0
for i in range(a, NA+1):
    sa = SA[i]
    for j in range(b, NB+1):
        sb = SB[j]
        ans = max(ans, f(findMax(f, c, NC)).val)
print(ans)