#include <bits/stdc++.h>

using namespace std;

//fast IO by yosupo
struct Scanner {
  FILE *fp = nullptr;
  char line[(1 << 15) + 1];
  size_t st = 0, ed = 0;

  void reread() {
    memmove(line, line + st, ed - st);
    ed -= st;
    st = 0;
    ed += fread(line + ed, 1, (1 << 15) - ed, fp);
    line[ed] = '\0';
  }

  bool succ() {
    while(true) {
      if(st == ed) {
        reread();
        if(st == ed) return false;
      }
      while(st != ed && isspace(line[st])) st++;
      if(st != ed) break;
    }
    if(ed - st <= 50) reread();
    return true;
  }

  template< class T, enable_if_t< is_same< T, string >::value, int > = 0 >
  bool read_single(T &ref) {
    if(!succ()) return false;
    while(true) {
      size_t sz = 0;
      while(st + sz < ed && !isspace(line[st + sz])) sz++;
      ref.append(line + st, sz);
      st += sz;
      if(!sz || st != ed) break;
      reread();
    }
    return true;
  }

  template< class T, enable_if_t< is_integral< T >::value, int > = 0 >
  bool read_single(T &ref) {
    if(!succ()) return false;
    bool neg = false;
    if(line[st] == '-') {
      neg = true;
      st++;
    }
    ref = T(0);
    while(isdigit(line[st])) {
      ref = 10 * ref + (line[st++] - '0');
    }
    if(neg) ref = -ref;
    return true;
  }

  template< class T >
  bool read_single(vector< T > &ref) {
    for(auto &d : ref) {
      if(!read_single(d)) return false;
    }
    return true;
  }

  void read() {}

  template< class H, class... T >
  void read(H &h, T &... t) {
    bool f = read_single(h);
    assert(f);
    read(t...);
  }

  Scanner(FILE *_fp) : fp(_fp) {}
};

struct Printer {
public:
  template< bool F = false >
  void write() {}

  template< bool F = false, class H, class... T >
  void write(const H &h, const T &... t) {
    if(F) write_single(' ');
    write_single(h);
    write< true >(t...);
  }

  template< class... T >
  void writeln(const T &... t) {
    write(t...);
    write_single('\n');
  }

  Printer(FILE *_fp) : fp(_fp) {}

  ~Printer() { flush(); }

private:
  static constexpr size_t SIZE = 1 << 15;
  FILE *fp;
  char line[SIZE], small[50];
  size_t pos = 0;

  void flush() {
    fwrite(line, 1, pos, fp);
    pos = 0;
  }

  void write_single(const char &val) {
    if(pos == SIZE) flush();
    line[pos++] = val;
  }

  template< class T, enable_if_t< is_integral< T >::value, int > = 0 >
  void write_single(T val) {
    if(pos > (1 << 15) - 50) flush();
    if(val == 0) {
      write_single('0');
      return;
    }
    if(val < 0) {
      write_single('-');
      val = -val;  // todo min
    }
    size_t len = 0;
    while(val) {
      small[len++] = char('0' + (val % 10));
      val /= 10;
    }
    reverse(small, small + len);
    memcpy(line + pos, small, len);
    pos += len;
  }

  void write_single(const string &s) {
    for(char c : s) write_single(c);
  }

  void write_single(const char *s) {
    size_t len = strlen(s);
    for(size_t i = 0; i < len; i++) write_single(s[i]);
  }

  template< class T >
  void write_single(const vector< T > &val) {
    auto n = val.size();
    for(size_t i = 0; i < n; i++) {
      if(i) write_single(' ');
      write_single(val[i]);
    }
  }
};

int main(){
    Scanner in(stdin);
    Printer out(stdout);
    int x, y, a, b, c;
    in.read(x, y, a, b, c);
    vector<int64_t> P(a), Q(b), R(c);
    for (int i = 0; i < a; i++)
        in.read(P[i]);
    for (int i = 0; i < b; i++)
        in.read(Q[i]);
    for (int i = 0; i < c; i++)
        in.read(R[i]);
        
    nth_element(P.begin(), P.begin() + x, P.end(), greater<int64_t>());
    nth_element(Q.begin(), Q.begin() + y, Q.end(), greater<int64_t>());

    for (int i = 0; i < x; i++)
        R.push_back(P[i]);

    for (int i = 0; i < y; i++)
        R.push_back(Q[i]);

    nth_element(R.begin(), R.begin() + x + y, R.end(), greater<int64_t>());
    out.writeln(accumulate(R.begin(), R.begin() + x + y, 0L));
}

Measured memory_bytes: 6384