#include <bits/stdc++.h>
using namespace std;
int nxi() {
  int a;
  cin >> a;
  return a;
}
vector<long long> a;
void inc(int i, long long v) {
  for (; i < a.size(); i |= i + 1) {
    a[i] = max(a[i], v);
  }
}
long long get(int r) {
  long long ans = 0;
  for (; r >= 0; r = (r & (r + 1)) - 1) {
    ans = max(ans, a[r]);
  }
  return ans;
}
long long get(int l, int r) { return get(r) - get(l - 1); }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
  int n = nxi(), p = nxi(), k = nxi();
  vector<int> a1(n), a2(n);
  int n1 = nxi();
  for (int i = 0; i < n1; ++i) {
    int v = nxi();
    a1[v - 1] = 1;
  }
  int n2 = nxi();
  for (int i = 0; i < n2; ++i) {
    int v = nxi();
    a2[v - 1] = 1;
  }
  int ans = 0;
  if (p > 2 * ((n - 1) / k + 1)) {
    for (int i = 0; i < n; ++i) {
      ans += a1[i] | a2[i];
    }
    cout << ans;
  } else {
    vector<vector<vector<int>>> d_empty(
        p + 1, vector<vector<int>>(k + 1, vector<int>(k + 1, 0)));
    vector<vector<vector<int>>> d_cur = d_empty, d_next = d_empty;
    d_cur[p][k][k] = 0;
    for (int i = k - 1; i < n; ++i) {
      for (int j = 0; j <= p; ++j) {
        for (int l1 = 1; l1 <= k; ++l1) {
          for (int l2 = 1; l2 <= k; ++l2) {
            int nextl1 = min(k, l1 + 1), nextl2 = min(k, l2 + 1);
            d_next[j][nextl1][nextl2] =
                max(d_next[j][nextl1][nextl2], d_cur[j][l1][l2]);
            if (j > 0) {
              int delta = 0;
              if (l1 == k || i + 1 == n) {
                for (int c = 0; c < l1; ++c) {
                  int ind = i - c;
                  if (a1[ind] && (c < l2 || !a2[ind])) ++delta;
                }
                d_next[j - 1][1][nextl2] =
                    max(d_next[j - 1][1][nextl2], d_cur[j][l1][l2] + delta);
              }
              delta = 0;
              if (l2 == k || i + 1 == n) {
                for (int c = 0; c < l2; ++c) {
                  int ind = i - c;
                  if (a2[ind] && (c < l1 || !a1[ind])) ++delta;
                }
                d_next[j - 1][nextl1][1] =
                    max(d_next[j - 1][nextl1][1], d_cur[j][l1][l2] + delta);
              }
            }
            if (j > 1 && (l2 == k && l1 == k || i + 1 == n)) {
              int delta = 0;
              for (int c = 0; c < max(l1, l2); ++c) {
                int ind = i - c;
                if (c < l1 && a1[ind] && (c < l2 || !a2[ind]) ||
                    c < l2 && a2[ind] && (c < l1 || !a1[ind]))
                  ++delta;
              }
              d_next[j - 2][1][1] =
                  max(d_next[j - 2][1][1], d_cur[j][l1][l2] + delta);
            }
          }
        }
      }
      d_cur = d_next;
      d_next = d_empty;
    }
    int ans = 0;
    for (int j = 0; j <= p; ++j) {
      for (int l1 = 1; l1 <= k; ++l1) {
        for (int l2 = 1; l2 <= k; ++l2) {
          ans = max(ans, d_cur[j][l1][l2]);
        }
      }
    }
    cout << ans;
  }
  return 0;
}
