#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
inline bool mina(A &first, B second) {
  return (first > second) ? (first = second, 1) : 0;
}
template <class A, class B>
inline bool maxa(A &first, B second) {
  return (first < second) ? (first = second, 1) : 0;
}
const int MAXN = 2e5 + 5;
const long long INF = (1LL << 61);
int R, C, K, Q;
int left_fish[MAXN];
int right_fish[MAXN];
bool safe_col[MAXN];
long long dp[MAXN][2];
int pre_row[MAXN];
int left_ladder[MAXN];
int right_ladder[MAXN];
void AddFish(int r, int c) {
  if (left_fish[r] == -1) {
    left_fish[r] = c;
    right_fish[r] = c;
  } else {
    mina(left_fish[r], c);
    maxa(right_fish[r], c);
  }
}
long long cal(int cr, int pp, int is_right, int right_l) {
  long long cost = 0;
  if (right_l) {
    if (right_ladder[pp] == -1)
      return INF;
    else {
      cost += right_ladder[pp] - pp;
      pp = right_ladder[pp];
    }
  } else {
    if (left_ladder[pp] == -1)
      return INF;
    else {
      cost += pp - left_ladder[pp];
      pp = left_ladder[pp];
    }
  }
  int cp_right = right_fish[cr];
  int cp_left = left_fish[cr];
  if (is_right) {
    if (pp >= cp_right)
      return cost + pp - cp_left + cp_right - cp_left;
    else if (pp >= cp_left)
      return cost + pp - cp_left + cp_right - cp_left;
    else
      return cost + cp_right - pp;
  } else {
    if (pp >= cp_right)
      return cost + pp - cp_left;
    else if (pp >= cp_left)
      return cost + cp_right - pp + cp_right - cp_left;
    else
      return cost + cp_right - pp + cp_right - cp_left;
  }
}
long long solve(int r, int is_right) {
  if (r == 0) {
    if (left_fish[r] == -1) {
      left_fish[0] = right_fish[0] = 0;
      dp[0][0] = dp[0][1] = 0;
    } else {
      dp[0][0] = right_fish[0] + right_fish[0] - left_fish[0];
      dp[0][1] = right_fish[0];
    }
    return dp[r][is_right];
  }
  if (dp[r][is_right] != -1) return dp[r][is_right];
  int pr = pre_row[r];
  int cc;
  for (int i = 0; (i) < (2); ++(i)) solve(pr, i);
  cc = is_right;
  dp[r][is_right] = cal(r, left_fish[pr], cc, 0) + dp[pr][0];
  mina(dp[r][is_right], cal(r, left_fish[pr], cc, 1) + dp[pr][0]);
  mina(dp[r][is_right], cal(r, right_fish[pr], cc, 0) + dp[pr][1]);
  mina(dp[r][is_right], cal(r, right_fish[pr], cc, 1) + dp[pr][1]);
  dp[r][is_right] += r - pr;
  return dp[r][is_right];
}
int main() {
  memset(left_fish, -1, sizeof(left_fish));
  memset(right_fish, -1, sizeof(right_fish));
  memset(dp, -1, sizeof(dp));
  memset(left_ladder, -1, sizeof(left_ladder));
  memset(right_ladder, -1, sizeof(right_ladder));
  int r, c;
  scanf("%d %d %d %d", &R, &C, &K, &Q);
  int max_r = -1;
  for (int i = 0; (i) < (K); ++(i)) {
    scanf("%d %d", &r, &c);
    r--, c--;
    AddFish(r, c);
    maxa(max_r, r);
  }
  for (int i = 0; (i) < (Q); ++(i)) {
    scanf("%d", &c);
    c--;
    safe_col[c] = true;
  }
  if (safe_col[0]) left_ladder[0] = 0;
  for (int i = 1; i < C; i++) {
    if (safe_col[i])
      left_ladder[i] = i;
    else
      left_ladder[i] = left_ladder[i - 1];
  }
  if (safe_col[C - 1]) right_ladder[C - 1] = C - 1;
  for (int i = C - 2; i >= 0; i--) {
    if (safe_col[i])
      right_ladder[i] = i;
    else
      right_ladder[i] = right_ladder[i + 1];
  }
  pre_row[0] = 0;
  for (int i = 1; i <= max_r; i++) {
    if (left_fish[i - 1] == -1) {
      pre_row[i] = pre_row[i - 1];
    } else {
      pre_row[i] = i - 1;
    }
  }
  cout << min(solve(max_r, 0), solve(max_r, 1)) << endl;
  return 0;
}
