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.util.*;
import java.io.*;

public class codeforces729C {
	public static boolean checkIfPossible(int[] distance,int k,int t,int fuel) {
		int time = 0;
		for(int i=0;i<=k;i++) {
			if(distance[i]>fuel) {
				return false;
			} else if(fuel>=2*distance[i]){
				time+=distance[i];
			} else {
				time+=(3*distance[i]-fuel);
			}
		}
		return time<=t;
	}
	
	public static int findingMinimumTime(int left,int right,int k,int t,int[] distance) {
		while(left<right) {
			int mid = (left+right)/2;
			
			if(checkIfPossible(distance,k,t,mid)) {
				right = mid;
			} else {
				left = mid+1;
			}
		}
		return right;
	}
	
	public static void main(String[] args) throws Exception{
		//InputReader in = new InputReader(new File("C:/Users/RED-DRAGON/workspace/input.txt"));
		InputReader in = new InputReader(System.in);
		//PrintWriter out = new PrintWriter(new File("C:/Users/RED-DRAGON/workspace/output.txt"));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		
		int n = in.nextInt();
		int k = in.nextInt();
		int s = in.nextInt();
		int t = in.nextInt();
		
		int[] c = new int[n+1];
		int[] v = new int[n+1];
		
		int vmax = Integer.MIN_VALUE;
		
		for(int i=0;i<n;i++) {
			c[i] = in.nextInt();
			v[i] = in.nextInt();
			vmax = Math.max(vmax, v[i]);
		}
		
		int[] g = new int[k];
		
		for(int i=0;i<k;i++) {
			g[i] = in.nextInt();
		}
		
		Arrays.sort(g);
		
		int[] distance = new int[k+1];
		distance[0] = g[0];
		for(int i=1;i<k;i++) {
			distance[i] = g[i] - g[i-1];
		}
		
		distance[k] = s-g[k-1];
		
		if(!checkIfPossible(distance,k,t,vmax)) {
			out.println(-1);
			return;
		}
		
		int minimumTime = findingMinimumTime(1,vmax,k,t,distance);
		
		int rslt = Integer.MAX_VALUE;
		for(int i=0;i<n;i++) {
			if(v[i]>=minimumTime) {
				rslt = Math.min(rslt, c[i]);
			}
		}
		
		out.println(rslt);
		
		out.close();
	}
	
	public static void debug(Object...args) {
        System.out.println(Arrays.deepToString(args));
    }
	
	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;
		
		public InputReader(File file) {
			try {
				reader = new BufferedReader(new FileReader(file));
				tokenizer = null;
			} catch(FileNotFoundException e) {
				e.printStackTrace();
			}
		}
		
		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream));
			tokenizer = null;
		}
		
		public String next() throws Exception {
			while(tokenizer == null || !tokenizer.hasMoreTokens()) {
				tokenizer = new StringTokenizer(reader.readLine());
			}
			return tokenizer.nextToken();
		}
		
		public String nextLine() throws Exception {
			String line = null;
			tokenizer = null;
			line = reader.readLine();
			return line;
		}
		
		public int nextInt() throws Exception {
			return Integer.parseInt(next());
		} 
		
		public double nextDouble() throws Exception {
			return Double.parseDouble(next());
		}
		
		public long nextLong() throws Exception {
			return Long.parseLong(next());
		}
	}
}
