#include <bits/stdc++.h>
int main(void) {
  int n, max_peeks, breadth;
  int r, s;
  scanf("%d %d %d", &n, &max_peeks, &breadth);
  bool left[1 + 1000] = {};
  bool right[1 + 1000] = {};
  int left_count[1 + 1000];
  int right_count[1 + 1000];
  int and_count[1 + 1000];
  scanf("%d", &r);
  for (int i = 0; i < r; i++) {
    int v;
    scanf("%d", &v);
    left[v] = true;
  }
  scanf("%d", &s);
  for (int i = 0; i < s; i++) {
    int v;
    scanf("%d", &v);
    right[v] = true;
  }
  left_count[0] = right_count[0] = and_count[0] = 0;
  for (int i = 1; i <= n; i++) {
    left_count[i] = left_count[i - 1] + left[i];
    right_count[i] = right_count[i - 1] + right[i];
    and_count[i] = and_count[i - 1] + (left[i] && right[i]);
  }
  if (max_peeks / 2 * breadth >= n) {
    printf("%d\n", left_count[n] + right_count[n] - and_count[n]);
    return 0;
  }
  int t[2][1 + 1000][1 + 1000];
  for (int j = 0; j <= n; j++) {
    for (int k = 0; k <= n; k++) {
      t[0][j][k] = 0;
    }
  }
  for (int peeks = 1; peeks <= max_peeks; peeks++) {
    for (int left = 0; left <= n; left++) {
      for (int right = std::max(0, left - breadth);
           right <= std::min(n, left + breadth); right++) {
        int& answer = t[peeks % 2][left][right];
        answer = t[!(peeks % 2)][left][right];
        if (left > 0 && abs((left - 1) - right) <= breadth) {
          answer = std::max(answer, t[peeks % 2][left - 1][right]);
        }
        if (right > 0 && abs((right - 1) - left) <= breadth) {
          answer = std::max(answer, t[peeks % 2][left][right - 1]);
        }
        if (left >= right) {
          int prev_left = std::max(0, left - breadth);
          for (int prev_right = right; prev_right >= prev_left; prev_right--) {
            answer = std::max(
                answer,
                t[!(peeks % 2)][prev_left][prev_right] + left_count[left] -
                    left_count[prev_left] -
                    std::max(0, and_count[prev_right] - and_count[prev_left]));
          }
        } else {
          int prev_right = std::max(0, right - breadth);
          for (int prev_left = left; prev_left >= prev_right; prev_left--) {
            answer = std::max(
                answer,
                t[!(peeks % 2)][prev_left][prev_right] + right_count[right] -
                    right_count[prev_right] -
                    std::max(0, and_count[prev_left] - and_count[prev_right]));
          }
        }
      }
    }
  }
  printf("%d\n", t[max_peeks % 2][n][n]);
  return 0;
}
