// fn read_line() -> String {
//     let mut s = String::new();
//     std::io::stdin().read_line(&mut s).unwrap();
//     s
// }

// fn split_whitespace(line: String) -> Vec<u32> {
//     line.split_whitespace()
//         .map(|s| s.parse().unwrap())
//         .collect()
// }

// fn reader() -> Vec<usize> {
//     let mut buffer = String::new();
//     io::stdin().read_to_string(&mut buffer);

//     let st: Vec<&str> = buffer.lines().collect();

//     let s: Vec<&str> = st.get(1).unwrap().clone().split_terminator(" ").collect();

//     s.iter()
//         .map(|v| v.trim().parse::<usize>().unwrap())
//         .collect()
// }

// fn solver(mut hs: Vec<usize>) -> usize {
//     let mut v: Vec<usize> = vec![0; hs.len()];;

//     for i in 1..hs.len() {
//         if hs[i - 1] >= hs[i] {
//             v[i] = v[i - 1] + 1;
//         }
//     }

//     let max = v.iter().max().unwrap().clone();
//     println!("{}", max);
//     max
// }

pub struct IO<R, W: std::io::Write>(R, std::io::BufWriter<W>);

impl<R: std::io::Read, W: std::io::Write> IO<R, W> {
    pub fn new(r: R, w: W) -> IO<R, W> {
        IO(r, std::io::BufWriter::new(w))
    }
    pub fn write<S: ToString>(&mut self, s: S) {
        use std::io::Write;
        self.1.write(s.to_string().as_bytes()).unwrap();
    }
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .0
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}

fn main() {
    let mut sc = IO::new(std::io::stdin(), std::io::stdout());
    let opts: Vec<usize> = sc.vec(5);

    let (x, y, r, g, c) = (opts[0], opts[1], opts[2], opts[3], opts[4]);

    let mut rs: Vec<usize> = sc.vec(r);
    let mut gs: Vec<usize> = sc.vec(g);
    let mut cs: Vec<usize> = sc.vec(c);

    rs.sort();
    gs.sort();
    cs.sort();

    rs.reverse();
    gs.reverse();
    cs.reverse();

    // println!("{:?}", rs);
    // println!("{:?}", gs);
    // let rs_top: &usize = &rs[..x].iter().sum::<usize>();
    // let gs_top: &usize = &gs[..y].iter().sum::<usize>();
    // let mut total = rs_top + gs_top;

    // let cap = std::cmp::min(std::cmp::max(x, y), cs.len());

    let mut b = rs[..x]
        .iter()
        .chain(&gs[..y])
        .chain(&cs[..])
        .cloned()
        .collect::<Vec<usize>>();
    b.sort();
    b.reverse();

    // println!("{:?}", b.iter().take(x + y).sum::<usize>());

    // for (i, item) in cs[..cap].iter().enumerate() {
    //     match (rs.get(i), gs.get(i)) {
    //         (Some(r), Some(g)) => {
    //             let min = std::cmp::min(r, g);
    //             if min < item {
    //                 total = total + (item - min);
    //             }
    //         }
    //         (Some(r), None) => {
    //             if r < item {
    //                 total = total + (item - r);
    //             }
    //         }
    //         (None, Some(r)) => {
    //             if r < item {
    //                 total = total + (item - r);
    //             }
    //         }
    //         _ => unreachable!(),
    //     }
    //     // if let Some(v) = rs.get(i) {
    //     //     if item > v {
    //     //         total = total + (item - v);
    //     //     }
    //     // }
    // }
    // println!("{} {} {}", &rs_top, &gs_top, &cap);
    // let cs_top: &usize = &cs[..cap].iter().sum::<usize>();

    sc.write(b.iter().take(x + y).sum::<usize>());
}

#[test]
fn evls() {
    assert_eq!(1, 2);
}

// #[cfg(test)]
// mod tests {
//     use super::*;

//     #[test]
//     fn fst() {
//         assert_eq!(solver(vec![4, 4, 5, 6, 6, 5, 5]), 3);
//     }

//     #[test]
//     fn snd() {
//         assert_eq!(solver(vec![10, 4, 8, 7, 3]), 2);
//     }

//     #[test]
//     fn thrd() {
//         assert_eq!(solver(vec![1, 2, 3, 4]), 0);
//         assert_eq!(solver(vec![1, 2]), 0);
//     }
// }


Measured memory_bytes: 14588