1 1 2 2
1000000000 1000000000
1
 1 1 1000000000 1000000000
100 1000000000
1
 1 1 10 18
5 6
5
 2 1 1000000000 2000000000
111 999999999
101 999999998
1
 4 13 400 600
13 30
1 19
1 160
1 113
58 73 15 319 194 362 128 157 336 162 77 90 96
 1 15 100 200
283 8
30 58 16 45 80 82 55 95 24 23 86 28 51 47 20
 3 2 300 400
24 68
13 65
15 113
127 177
 1 1 2 1
1 10
1
 4 2 7 15
10 9
4 4
9 3
4 10
1 6
 2 1 1000000000 2000000000
111 1000000000
101 1000000000
5
 2 1 1000000000 2000000000
111 999999998
101 999999998
1
 1 1 1000000000 1000000000
1 1000000000
1

1000000000
 -1
 5
 111
 1
 -1
 -1
 -1
 4
 101
 -1
 -1

import java.io.*;
import java.util.*;

public class SolveC {
	BufferedReader br;
	StringTokenizer st;
	PrintWriter out;

	String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			st = new StringTokenizer(br.readLine());
		}
		return st.nextToken();
	}

	int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(nextToken());
	}
	public static void main(String[] args) throws NumberFormatException, IOException {
		new SolveC().run();
	}

	void run() throws NumberFormatException, IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		out.close();
	}
	class Segment implements Comparable<Segment>{
		long begin;
		long end;
		long len;
		public Segment(long begin, long end) {
			this.begin = begin;
			this.end = end;
			this.len = end - begin;
		}
		@Override
		public int compareTo(Segment that) {
			if (this.len == that.len) {
				return Long.compare(this.begin, that.begin);
			}
			return Long.compare(this.len, that.len);
		}
		
	}
	void solve() throws NumberFormatException, IOException {
			int n = nextInt();
			int k = nextInt();
			long s = nextInt();
			long t = nextInt();
			long[] c = new long[n];
			long[] v = new long[n];
			for (int i = 0; i < n; i++) {
				c[i] = nextLong();
				v[i] = nextLong();
			}
			long[] g = new long[k + 2];
			g[0] = 0;
			g[1] = s;
			for (int i = 2; i <= k + 1; i++) {
				g[i] = nextLong();
			}
			Arrays.sort(g);
			Segment[] segments = new Segment[k + 1];
			for (int i = 0; i <= k; i++) {
				segments[i] = new Segment(g[i], g[i + 1]);
			}
			if (s > t) {
				out.println(-1);
				return;
			}
			Arrays.sort(segments);
			long vcur = segments[segments.length - 1].len;
			long tcur = 2 * s;
			for (Segment seg : segments) {
				long len = seg.len;
				long mint = tcur;
				long minv = vcur;
				long maxt = tcur - len;
				long maxv = Math.max(vcur, len * 2);
				if (maxt > t) {
					tcur = maxt;
					vcur = maxv;
					continue;
				} else {
					//[maxt,mint]
					long res = mint - 2 * len;
					long a = t - len - res;
					long b = len - a;
					tcur = t;
					vcur = Math.max(vcur, a + 2 * b);
					break;
				}
			}
			if (tcur != t) {
				out.println(-1);
				return;
			}
			long ans = Long.MAX_VALUE;
			for (int i =0; i < n; i++) {
				if (v[i] >= vcur) {
					ans = Math.min(ans, c[i]);
				}
			}
			if (ans == Long.MAX_VALUE) {
				out.println(-1);
				return;
			}
			out.println(ans);
	}
}
