#include<bits/stdc++.h>
using namespace std;

#define int long long

const int MAXN = 200010;

vector<int> fans;
vector<pair<int,int>> v[MAXN];

vector<int> pos;

namespace cactus{
	vector<vector<int>> get_cycles(int* to, int n){
		queue<int> q;
 
		vector<int> indeg(n, 0);
		for(int i = 0; i < n; ++i) indeg[to[i]]++;
		for(int i = 0; i < n; ++i) if(indeg[i] == 0)
			q.push(i);
 
		while(q.size()){
			int x = q.front(); q.pop();
			if(--indeg[to[x]] == 0)
				q.push(to[x]);
		}
 
		vector<vector<int>> cycles;
		for(int i = 0; i < n; ++i) if(indeg[i] == 1){
			vector<int> cycle;
			int x = to[i];
			while(true){
				cycle.push_back(x);
				indeg[x] = 0;
				if(x == i) break;
				x = to[x];
			}
			cycles.push_back(cycle);
		}
		return cycles;
	}
}

namespace circular_arc{
bool between(int l, int r, int x){
  if(l > r) return (x >= l || x <= r);
  else return (x >= l && x <= r);
}
 
bool intersect(pair<int,int> &a, pair<int,int> &b){
	return (between(a.first, a.second, b.first) || between(a.first, a.second, b.second) || 
		between(b.first, b.second, a.first) || between(b.first, b.second, a.second));
}
 
struct Point{
	int x, arc_id;
	bool is_l;
	bool operator<(const Point &b) const{
		if(x == b.x) return is_l > b.is_l;
		else return x < b.x;
	}
};
 
vector<pair<int,int>> v;
vector<int> gd; // last one is not in GD

Point pts[2 * MAXN];
int next[MAXN];
bool is_open[MAXN];
int n;
int time_vis[MAXN][2];
 
void compute_next(){
	memset(is_open, 0, sizeof(bool) * n);
	for(int i = 0; i < n; ++i){
		time_vis[i][0] = time_vis[i][1] = next[i] = -1;
	}
 
	queue<int> closed;
	for(int i = 0; i < 6 * n; ++i){
		int j = i % (2 * n);
		auto [p, arc_id, is_l] = pts[j];
 
		if(is_l){ // is L
			time_vis[arc_id][0] = i;
			is_open[arc_id] = 1;
		}else if(is_open[arc_id]){ // is R and already openned
			time_vis[arc_id][1] = i;
			is_open[arc_id] = 0;
			while(closed.size()){
				if(closed.front() != arc_id){
					if(time_vis[arc_id][0] < time_vis[closed.front()][1]) 
						break;
				}
				next[closed.front()] = arc_id;
				closed.pop();
			}
			if(next[arc_id] == -1)
				closed.push(arc_id);
		}
	}
}
 
void compute_gd(const vector<int> &cycle){
	gd.clear();
	int i = cycle[0];
	gd.push_back(i);
	for(int j = 1; j < cycle.size(); ++j){
		gd.push_back(cycle[j]);
		if(intersect(v[i], v[cycle[j]])) break;
	}
}

void built_pts(int MAX_COORD){
	if(true){ // v sorted
	
	auto norm = [&](int x){ return (x + MAX_COORD) % MAX_COORD; };
	for(int i = 0; i < n; ++i){
		pts[i] = {v[i].first, i, 1};
		pts[i + n] = {v[i].second, i, 0};
	}
	for(auto &[l, r] : v) l = norm(l), r = norm(r);	

	inplace_merge(pts, pts + n, pts + 2 * n);
	int m = lower_bound(pts, pts + 2 * n, MAX_COORD, [](Point &p, int x){
		return p.x < x;
	}) - pts;
	for(int i = 0; i < 2 * n; ++i) pts[i].x = norm(pts[i].x);
	inplace_merge(pts, pts + n, pts + 2 * n);

	return;
	}

	// v not sorted
	for(int i = 0; i < n; ++i){
		pts[2 * i] = {v[i].first, i, 1};
		pts[2 * i + 1] = {v[i].second, i, 0};
	}

	sort(pts, pts + 2 * n, [](Point &a, Point &b){
		if(a.x == b.x) return a.is_l > b.is_l;
		else return a.x < b.x;
	});
}
 
int get_min_clique(const vector<pair<int,int>> &_v, int MAX_COORD = MAXN){
	v = _v;
	n = v.size();
	if(n == 0) return 0;
	 
	built_pts(MAX_COORD);
	compute_next();
	auto cycles = cactus::get_cycles(next, n);
 
	compute_gd(cycles[0]);
 
	if(gd.size() == 1) return 1;
	if(gd.front() == gd.back()) return gd.size() - 1;
	else return gd.size();
}
}

vector<int> fanid;

bool solve(int will_walk, int p){
  int n = pos.size() / 2;

  vector<pair<int,int>> intervs;

	int curr_r = 0, curr_l = 0;
  for(auto i : fanid){
		// andar r enquanto menor que nxt_pos
		int nxt_pos_r = pos[i] + will_walk;
		while(curr_r < pos.size() && pos[curr_r] <= nxt_pos_r)
			curr_r++;

		// andar l enquanto menor que pos
		int nxt_pos_l = pos[i + n] - will_walk;
		while(curr_l < pos.size() && pos[curr_l] < nxt_pos_l)
			curr_l++;

		int dist_l = i + n - curr_l;
		int dist_r = curr_r - i;
    if(dist_l + dist_r >= n) continue;

    // intervs.push_back({curr_l, curr_r - 1 });
    intervs.push_back({curr_l, curr_r - 1});
  }

	vector<int> x[2];
	for(auto [l, r] : intervs){
		x[0].push_back(l);
		x[1].push_back(r);
	}
	for(int j = 0; j < 2; ++j){
		vector<int> u = x[j];
		sort(u.begin(), u.end());
		assert(u == x[j]);
	}

  int needed = circular_arc::get_min_clique(intervs, n);
  return needed <= p;
}

int32_t main(){
  cin.tie(NULL)->sync_with_stdio(false);
  int n, m, k, p; cin >> n >> m >> k >> p;
  
  vector<int> c(n, 0);
  for(int i = 0; i < m; ++i){
    int j, t; cin >> j >> t; j--;
    c[j] = t;
  }

  for(int i = 0; i < k; ++i){
    int x; cin >> x; x--;
    fans.push_back(x);
  }
	sort(fans.begin(), fans.end());

  vector<int> good;
  for(int i = 0; i < n; ++i) if(c[i] == 0){
    good.push_back(i);
  }

  if(good.size() == 1){
    cout << 0 << "\n";
    return 0;
  }

  auto id = [&](int x){
    return (int) (lower_bound(good.begin(), good.end(), x) - good.begin());
  };

  for(auto x : fans) fanid.push_back(id(x));

  for(int i = 0; i < n; ++i) if(c[i] == 0){
		// i nao tem quarentena

    int l = (i - 1 + n) % n;
    int r = (i + 1) % n;
    int cost_l = 1, cost_r = 1;
    
    while(c[l] != 0){
      cost_l += c[l] + 1;
      l = (l - 1 + n) % n;
    }

    while(c[r] != 0){
      cost_r += c[r] + 1;
      r = (r + 1) % n;
    }

    v[id(i)].push_back({id(l), cost_l});
    v[id(i)].push_back({id(r), cost_r});
  }

  int curr_pos = 0;
  for(int i = 0; i < 2 * good.size(); ++i){
    pos.push_back(curr_pos);
    curr_pos += v[i % good.size()][1].second;
  }

  int tot = pos[good.size()];

  if(solve(0, p)){
    cout << 0 << "\n";
  }else{
    int ans = 0;
    int pot = (1LL << 36);
    while(pot){
      int mans = ans + pot;
      if(mans < tot && !solve(mans, p)){
        ans = mans;
      }
      pot /= 2;
    }
    cout << ans + 1 << "\n";
  }

}