import           Control.Monad
import           Control.Monad.ST
import qualified Data.Array                    as A
import qualified Data.Array.ST                 as ST
import qualified Data.Array.Unboxed            as AU
import qualified Data.ByteString.Char8         as BS
import           Data.Char
import           Data.Int
import qualified Data.IntMap                   as IM
import           Data.List
import qualified Data.Map                      as M
import           Data.Maybe
import           Data.Ord
import qualified Data.Set                      as S
import           Data.Time
import qualified Data.Vector                   as V
import qualified Data.Vector.Mutable           as VM
import qualified Data.Vector.Unboxed           as VU
import qualified Data.Vector.Unboxed.Mutable   as VUM

readInt :: IO [Int]
readInt = map (fst . fromJust . BS.readInt) . BS.words <$> BS.getLine

readInts :: Int -> IO [[Int]]
readInts n = replicateM n readInt

readString :: IO [String]
readString = map BS.unpack . BS.words <$> BS.getLine

readStrings :: Int -> IO [[String]]
readStrings n = replicateM n <$> readString

toPair :: [a] -> (a, a)
toPair [x, y] = (x, y)

main = do
  [x, y, a, b, c] <- readInt
  p               <- readInt
  q               <- readInt
  r               <- readInt
  print $ solve x y p q r

solve :: Int -> Int -> [Int] -> [Int] -> [Int] -> Int
solve x y p q r = g p' q' r' x y 0
 where
  p' = take x $ sortOn Down p
  q' = take y $ sortOn Down q
  r' = take (x + y) $ (sortOn Down r ++ repeat 0)

f _ 0 _ 0 _ acc = acc

f _ 0 (q : qs) y (r : rs) acc | q >= r    = f [] 0 qs (y - 1) (r : rs) (acc + q)
                              | otherwise = f [] 0 (q : qs) (y - 1) rs (acc + r)

f (p : ps) x _ 0 (r : rs) acc
  | p >= r    = f ps (x - 1) [] 0 (r : rs) (acc + p)
  | otherwise = f (p : ps) (x - 1) [] 0 rs (acc + r)

f (p : ps) x (q : qs) y (r : rs) acc
  | p >= q && p >= r = f ps (x - 1) (q : qs) y (r : rs) (acc + p)
  | q >= p && q >= r = f (p : ps) x qs (y - 1) (r : rs) (acc + q)
  | r >= p && p >= q = f (p : ps) x (q : qs) (y - 1) rs (acc + r)
  | otherwise        = f (p : ps) (x - 1) (q : qs) y rs (acc + r)

g _  _  _  0 0 acc = acc

g ps qs [] x y acc = acc + sum (take x ps) + sum (take y qs)

g _ (q : qs) (r : rs) 0 y acc | q >= r    = g [] qs (r : rs) 0 (y - 1) (acc + q)
                              | otherwise = g [] (q : qs) rs 0 (y - 1) (acc + r)

g (p : ps) _ (r : rs) x 0 acc
  | p >= r    = g ps [] (r : rs) (x - 1) 0 (acc + p)
  | otherwise = g (p : ps) [] rs (x - 1) 0 (acc + r)

g (p : ps) (q : qs) (r : rs) x y acc
  | p == maximum [p, q, r] = g ps (q : qs) (r : rs) (x - 1) y (acc + p)
  | q == maximum [p, q, r] = g (p : ps) qs (r : rs) x (y - 1) (acc + q)
  | r == maximum [p, q, r] && last ps > last qs = g (p : ps)
                                                    (q : qs)
                                                    rs
                                                    x
                                                    (y - 1)
                                                    (acc + r)
  | otherwise = g (p : ps) (q : qs) rs (x - 1) y (acc + r)
