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 javax.print.attribute.HashAttributeSet;
	
	import java.io.*;
	import java.lang.*;
		
	public class code2
		{
	
			public static void main(String[] args)
			{
				InputReader in = new InputReader(System.in);
				PrintWriter pw = new PrintWriter(System.out);
				
				//Code starts..
				


				
				int n = in.nextInt();
				long k = in.nextLong();
				long s = in.nextLong();
				long t = in.nextLong();
				pair[] p = new pair[n];
				for(int i=0; i<n; i++)
				{
					int x = in.nextInt();
					int y = in.nextInt();
					
					p[i] = new pair(y, x);
					
				}
				
				long[] a = new long[(int)k+2];
				for(int i=1; i<=k; i++)
					a[i] = in.nextLong();
				a[(int)k+1] = s;
				
				Arrays.sort(p);
				long ll = p[0].x;
				long rl = p[n-1].x;
				long mid = 0;		
				long ans = rl;
				
				while(rl-ll>1)
				{
					mid =  (rl+ll)/2;
					
					
					
					long time = 0;
					for(int i=1; i<k+2; i++)
					{
						
						long tmp = a[i] - a[i-1];
						if(tmp>mid)
							time = INF;
						else
						{
						long x = Math.min(tmp, mid - tmp);
						time += x + (tmp-x)*2;
						}
					}
					
					if(time>t)
						ll = mid+1;
					else 
					{
						ans = mid;
						rl = mid -1;
						
					}
					
					
					
				}
				long a2 = -1;
				long prise = INF;
				for(int i=0; i<n; i++)
				{
					if(p[i].x>=ans && p[i].y<prise)
					{
						prise = p[i].y;
						a2 = p[i].x;
					}
						
				}
				if(a2!=-1)
				pw.print(prise);
				else
					pw.print(-1);
				
				
				
				//Code ends....
				
				pw.flush();
				pw.close();
			}
		
		
			
			
			
			static class InputReader 
			{
				 
				private final InputStream stream;
				private final byte[] buf = new byte[8192];
				private int curChar, snumChars;
				private SpaceCharFilter filter;
		 
				public InputReader(InputStream stream) 
				{
					this.stream = stream;
				}
		 
				public int snext() 
				{
					if (snumChars == -1)
						throw new InputMismatchException();
					if (curChar >= snumChars) 
					{
						curChar = 0;
						try 
						{
							snumChars = stream.read(buf);
						} 
						catch (IOException e) 
						{
							throw new InputMismatchException();
						}
						if (snumChars <= 0)
							return -1;
					}
					return buf[curChar++];
				}
		 
				public int nextInt() 
			    {
					int c = snext();
					while (isSpaceChar(c)) 
					{
						c = snext();
					}
					int sgn = 1;
					if (c == '-')
				    {
						sgn = -1;
						c = snext();
					}
					int res = 0;
					do 
					{
						if (c < '0' || c > '9')
							throw new InputMismatchException();
						res *= 10;
						res += c - '0';
						c = snext();
					} while (!isSpaceChar(c));
					return res * sgn;
				}
		 
				public long nextLong()
			    {
					int c = snext();
					while (isSpaceChar(c)) 
					{
						c = snext();
					}
					int sgn = 1;
					if (c == '-') 
					{
						sgn = -1;
						c = snext();
					}
					long res = 0;
					do 
					{
						if (c < '0' || c > '9')
							throw new InputMismatchException();
						res *= 10;
						res += c - '0';
						c = snext();
					} while (!isSpaceChar(c));
					return res * sgn;
				}
		 
				public int[] nextIntArray(int n) 
				{
					int a[] = new int[n];
					for (int i = 0; i < n; i++) 
					{
						a[i] = nextInt();
					}
					return a;
				}
		 
				public String readString()
			    {
					int c = snext();
					while (isSpaceChar(c)) 
					{
						c = snext();
					}
					StringBuilder res = new StringBuilder();
					do 
					{
						res.appendCodePoint(c);
						c = snext();
					} while (!isSpaceChar(c));
					return res.toString();
				}
		 
				public String nextLine() 
				{
					int c = snext();
					while (isSpaceChar(c))
						c = snext();
					StringBuilder res = new StringBuilder();
					do 
					{
						res.appendCodePoint(c);
						c = snext();
					} while (!isEndOfLine(c));
					return res.toString();
				}
		 
				public boolean isSpaceChar(int c) 
				{
					if (filter != null)
						return filter.isSpaceChar(c);
					return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
				}
		 
				private boolean isEndOfLine(int c) 
				{
					return c == '\n' || c == '\r' || c == -1;
				}
		 
				public interface SpaceCharFilter
			    {
					public boolean isSpaceChar(int ch);
				}
			}
			public static long c = 0;
			
			public static long mod = 1000000007;
			public static int d;
			public static int p;
			public static int q;
			public static boolean flag;
			public static long INF= Long.MAX_VALUE;
			
			public static long fun(int[] a, int[] b, int m,int n) {
				long result =0;
				for(int i=0; i<m; i++)
					for(int j=0; j<m; j++)
					{
						long[] fib  = new long[Math.max(2, n+2)];
						fib[1] = a[i];
						fib[2] = b[j];
						for(int k=3; k<=n; k++)
							fib[k] = (fib[k-1]%mod + fib[k-2]%mod)%mod;
						result = (result%mod + fib[n]%mod)%mod;
					}
				
				return result;
				
			}
			
			
			public static double slope(pair p1, pair p2)
			{
				double m = INF;
				if((p1.x - p2.x)!=0)
				m =  p1.y - p2.y/(p1.x - p2.x); 
				
				
				return Math.abs(m);
				
			}
			
			
			public static int count(String[] s, int f)
			{
				int count = 0;
				int n = s[0].length();
				
				if(f==1)
				{
				for(int i = 0; i<n; i++)
				{
					for(int j=0; j<n; j++)
					{
						if(i%2==0)
						{
							if(j%2==0 && s[i].charAt(j)=='0')
								count++;
							if(j%2==1 && s[i].charAt(j)=='1')
								count++;
						}
						if(i%2==1)
						{
							if(j%2==1 && s[i].charAt(j)=='0')
								count++;
							if(j%2==0 && s[i].charAt(j)=='1')
								count++;
						}
						
					}
				}
				}
				else
				{
				
				 count = 0;
				
				for(int i = 0; i<n; i++)
				{
					for(int j=0; j<n; j++)
					{
						if(i%2==1)
						{
							if(j%2==0 && s[i].charAt(j)=='0')
								count++;
							if(j%2==1 && s[i].charAt(j)=='1')
								count++;
						}
						if(i%2==0)
						{
							if(j%2==1 && s[i].charAt(j)=='0')
								count++;
							if(j%2==0 && s[i].charAt(j)=='1')
								count++;
						}
						
					}
				}
	
				}	
					
			
				return count;
				
				
				
			}
					
			public static  int gcd(int p2, int p22)
			{
			    if (p2 == 0)
			        return (int) p22;
			    return gcd(p22%p2, p2);
			}
			
				
		
			
			
			public static int findGCD(int arr[], int n)
			{
			    int result = arr[0];
			    for (int i=1; i<n; i++)
			        result = gcd(arr[i], result);
			 
			    return result;
			}
			
		
	
			public static void nextGreater(long[] a, int[] ans)
			{
				
				Stack<Integer> stk = new Stack<>();
				stk.push(0);
				
				
				for(int i=1; i<a.length; i++)
				{
					
					if(!stk.isEmpty())
					{
					int s = stk.pop();
					while(a[s]<a[i])
					{
						ans[s] = i;
						if(!stk.isEmpty())
							s = stk.pop();
						else
							break;
					}
					if(a[s]>=a[i])
						stk.push(s);
					}
					
					stk.push(i);
					
				}
				return;
				
			}
			
			public static void nextGreaterRev(long[] a, int[] ans)
			{
				
				int n = a.length;
				int[] pans = new int[n];
				Arrays.fill(pans, -1);
				long[] arev = new long[n];
				for(int i=0; i<n; i++)
					arev[i] = a[n-1-i];
				
				Stack<Integer> stk = new Stack<>();
				stk.push(0);
				
				
				for(int i=1; i<n; i++)
				{
					
					if(!stk.isEmpty())
					{
					int s = stk.pop();
					while(arev[s]<arev[i])
					{
						pans[s] = n - i-1;
						if(!stk.isEmpty())
							s = stk.pop();
						else
							break;
					}
					if(arev[s]>=arev[i])
						stk.push(s);
					}
					
					stk.push(i);
					
				}
				
				//for(int i=0; i<n; i++)
					//System.out.print(pans[i]+" ");
				
				for(int i=0; i<n; i++)
					ans[i] = pans[n-i-1];
				
				
				
				return;
				
			}
			
			
			public static void nextSmaller(long[] a, int[] ans)
			{
				
				Stack<Integer> stk = new Stack<>();
				stk.push(0);
				
				
				for(int i=1; i<a.length; i++)
				{
					
					if(!stk.isEmpty())
					{
					int s = stk.pop();
					while(a[s]>a[i])
					{
						ans[s] = i;
						if(!stk.isEmpty())
							s = stk.pop();
						else
							break;
					}
					if(a[s]<=a[i])
						stk.push(s);
					}
					
					stk.push(i);
					
				}
				return;
				
			}
			
			
			
			
		    public static long lcm(int[] numbers) {
		        long lcm = 1;
		        int divisor = 2;
		        while (true) {
		            int cnt = 0;
		            boolean divisible = false;
		            for (int i = 0; i < numbers.length; i++) {
		                if (numbers[i] == 0) {
		                    return 0;
		                } else if (numbers[i] < 0) {
		                    numbers[i] = numbers[i] * (-1);
		                }
		                if (numbers[i] == 1) {
		                    cnt++;
		                }
		                if (numbers[i] % divisor == 0) {
		                    divisible = true;
		                    numbers[i] = numbers[i] / divisor;
		                }
		            }
		            if (divisible) {
		                lcm = lcm * divisor;
		            } else {
		                divisor++;
		            }
		            if (cnt == numbers.length) {
		                return lcm;
		            }
		        }
		    }
			public static long fact(long n) {
				
				long factorial = 1;
				 for(int i = 1; i <= n; i++)
			        {
			            factorial *= i;
			        }
				 return factorial;
			}
			
			
			
			public static int lowerLimit(int[] a, int n) {
				int ans = 0;
				
				int ll = 0;
				int rl = a.length-1;
			//	System.out.println(a[rl]+" "+n);
				if(a[0]>n)
					return 0;
				if(a[0]==n)
					return 1;
				else if(a[rl]<=n)
					return rl+1;
			
				while(ll<=rl)
				{
					
					int mid = (ll+rl)/2;
					if(a[mid]==n)
					{
						ans = mid + 1;
						break;
					}
					
					else if(a[mid]>n)
					{
						rl = mid-1;
						
					}
					else
					{
						ans = mid+1;
						ll = mid+1;
					}
				}
				
				return ans; 
			}
			
			
			
			public static long[] sort(long[] a)
			{
				Random gen = new Random();
				int n = a.length;
				for(int i=0;i<n;i++)
				{
					int ind = gen.nextInt(n-i)+i;
					long temp = a[ind];
					a[ind] = a[i];
					a[i] = temp;
				}
				
				Arrays.sort(a);
				return a;
			}
			
			public static int[] sort(int[] a)
			{
				Random gen = new Random();
				int n = a.length;
				for(int i=0;i<n;i++)
				{
					int ind = gen.nextInt(n-i)+i;
					int temp = a[ind];
					a[ind] = a[i];
					a[i] = temp;
				}
				
				Arrays.sort(a);
				return a;
			}
			
			
			public static long choose(long total, long choose){
			    if(total < choose)
			        return 0;
			    if(choose == 0 || choose == total)
			        return 1;
			    return (choose(total-1,choose-1)+choose(total-1,choose))%mod;
			}
			
			public static int[] suffle(int[] a,Random gen)
			{
				int n = a.length;
				for(int i=0;i<n;i++)
				{
					int ind = gen.nextInt(n-i)+i;
					int temp = a[ind];
					a[ind] = a[i];
					a[i] = temp;
				}
				return a;
			}
			
			public static int floorSearch(int arr[], int low, int high, int x)
			{
			    if (low > high)
			        return -1;
			 
			    if (x > arr[high])
			        return high;
			    int mid = (low+high)/2;
			 
			 
			    if (mid > 0 && arr[mid-1] < x && x < arr[mid])
			        return mid-1;
			 
			    if (x < arr[mid])
			        return floorSearch(arr, low, mid-1, x);
			 
			    return floorSearch(arr, mid+1, high, x);
			}
			
			
			public static void swap(int a, int b){
				int temp = a;
				a = b;
				b = temp;
			}
			public static ArrayList<Integer> primeFactorization(int n)
			{
				ArrayList<Integer> a =new ArrayList<Integer>();
				for(int i=2;i*i<=n;i++)
				{
					while(n%i==0)
					{
						a.add(i);
						n/=i;
					}
				}
				if(n!=1)
					a.add(n);
				return a;
			}
			
			
			public static void sieve(boolean[] isPrime,int n)
			{
				for(int i=1;i<n;i++)
					isPrime[i] = true;
				
				isPrime[0] = false;
				isPrime[1] = false;
				
				for(int i=2;i*i<n;i++)
				{
					if(isPrime[i] == true)
					{
						for(int j=(2*i);j<n;j+=i)
							isPrime[j] = false;
					}
				}
			}
			
	public static void factSieve(int[] a, int n) {
				
				
				for(int i=2; i<=n; i+=2)
					a[i] = 2;
				
				
				for(int i=3; i<=n; i+=2)
				{
					if(a[i]==0)
					{
						a[i] = i;
						
						for(int j=i; j*i<=n; j++)
						{
							a[i*j] = i;	
						}
					}
				}
				
				int k = 1000;
				while(k!=1)
				{
					System.out.print(a[k]+" ");
					k /= a[k];
					
				}
			}
		
			
			public static int lowerbound(ArrayList<Long> net, long c2) {
				int i=Collections.binarySearch(net, c2);
				if(i<0)
					i = -(i+2);
				return i;
				
				
			}
			
			public static int lowerboundArray(long[] psum, long c2) {
				int i=Arrays.binarySearch(psum, c2);
				if(i<0)
					i = -(i+2);
				return i;
				
				
			}
			
			
			public static int uperbound(ArrayList<Long> net, long c2) {
				int i=Collections.binarySearch(net, c2);
				if(i<0)
					i = -(i+1);
				return i;
				
				
			}
			public static int uperboundArray(long[] psum, long c2) {
				int i=Arrays.binarySearch(psum, c2);
				if(i<0)
					i = -(i+1);
				return i;
				
				
			}
			
			
			public static int GCD(int a,int b)
			{
				if(b==0)
					return a;
				else
					return GCD(b,a%b);
			}
			
			public static long GCD(long a,long b)
			{
				if(b==0)
					return a;
				else
					return GCD(b,a%b);
			}
			
			public static void extendedEuclid(int A,int B)
			{
				if(B==0)
				{
					d = A;
					p = 1 ;
					q = 0;
				}
				else
				{
					extendedEuclid(B, A%B);
					int temp = p;
					p = q;
					q = temp - (A/B)*q;
				}
			}
			
			public static long LCM(long a,long b)
			{
				return (a*b)/GCD(a,b);
			}
			
			public static int LCM(int a,int b)
			{
				return (a*b)/GCD(a,b);
			}
			
			public static int binaryExponentiation(int x,int n)
			{
			    int result=1;
			    while(n>0)
			    {
			        if(n % 2 ==1)
			            result=result * x;
			        x=x*x;
			        n=n/2;
			    }
			    return result;
			}
			
			
			public static int[] countDer(int n)
		    {
		        int der[] = new int[n + 1];
		     
		        der[0] = 1;
		        der[1] = 0;
		        der[2] = 1;
		     
		        for (int i = 3; i <= n; ++i)
		            der[i] = (i - 1) * (der[i - 1] + der[i - 2]);
		     
		        // Return result for n
		        return der;
		    }
			
			
			 static long binomialCoeff(int n, int k)
			    {
			    long C[][] = new long[n+1][k+1];
			    int i, j;
			     
			        // Calculate  value of Binomial Coefficient in bottom up manner
			    for (i = 0; i <= n; i++)
			    {
			        for (j = 0; j <= Math.min(i, k); j++)
			        {
			            // Base Cases
			            if (j == 0 || j == i)
			                C[i][j] = 1;
			      
			            // Calculate value using previosly stored values
			            else
			                C[i][j] = C[i-1][j-1] + C[i-1][j];
			          }
			     }
			      
			    return C[n][k];
			    }
			
			public static long binaryExponentiation(long x,long n)
			{
			    long result=1;
			    while(n>0)
			    {
			        if(n % 2 ==1)
			            result=result * x;
			        x=(x%mod * x%mod)%mod;
			        n=n/2;
			    }
			    return result;
			}
			
			public static int modularExponentiation(int x,int n,int M)
			{
			    int result=1;
			    while(n>0)
			    {
			        if(n % 2 ==1)
			            result=(result * x)%M;
			        x=(x*x)%M;
			        n=n/2;
			    }
			    return result;
			}
			
			public static long modularExponentiation(long x,long n,long M)
			{
			    long result=1;
			    while(n>0)
			    {
			        if(n % 2 ==1)
			            result=(result * x)%M;
			        x=(x*x)%M;
			        n=n/2;
			    }
			    return result;
			}
			
			public static int modInverse(int A,int M)
			{
			    return modularExponentiation(A,M-2,M);
			}
			
			public static long modInverse(long A,long M)
			{
			    return modularExponentiation(A,M-2,M);
			}
			
			
			public static boolean checkYear(int year)
		    {
				if (year % 400 == 0)
		            return true;
		     
		        if (year % 100 == 0)
		            return false;
		     
		        if (year % 4 == 0)
		            return true;
		        return false;
		    }
			
			public static boolean isPrime(int n)
			{
			    
			    if (n <= 1)  return false;
			    if (n <= 3)  return true;
			    
			    if (n%2 == 0 || n%3 == 0) 
			    	return false;
			 
			    for (int i=5; i*i<=n; i=i+6)
			    {
			        if (n%i == 0 || n%(i+2) == 0)
			           return false;
			    }
			    
			    return true;
			}
			
			static class pair implements Comparable<pair>
	 
			{
				Long x, y;
				pair(long cur,long y)
				{
					this.x=cur;
					this.y=y;
				}
				
				public int compareTo(pair o) {
					int result =(int) x.compareTo((long)o.x);
					if(result==0)
						result = (int) y.compareTo((long)o.y);
					
					return result;
				}  
				
				public String toString()
				{
					return x+" "+y;
				}
				
				public boolean equals(Object o)
				{
					if (o instanceof pair)
				    {
						pair p = (pair)o;
						return p.x == x && p.y == y ;
					}
					return false;
				}
				
				public int hashCode()
				{
					return new Long(x).hashCode()*31 + new Long(y).hashCode();
				}
			}
		
			
			/*static class triplet implements Comparable<triplet>
			{
				Integer x,y,z;
				triplet(int x,int y,int z)
				{
					this.x = x;
					this.y = y;
					this.z = z;
				}
				
				public  int compareTo(triplet o)
				{
					int result = x.compareTo(o.x);
					if(result==0)
						result =  y.compareTo(o.y);
					if(result==0)
						result = z.compareTo(o.z);
	
					return result;
				}
				
				public boolean equlas(Object o)
				{
					if(o instanceof triplet)
					{
						triplet p = (triplet)o;
						return x==p.x && y==p.y && z==p.z;
					}
					return false;
				}
				
				public String toString()
				{
					return x+" "+y+" "+z;
				}
				public int hashCode()
				{
					return new Long(x).hashCode()*31 + new Long(y).hashCode() + new Long(z).hashCode(); 
				}
			}
			
	
			
			
			
		
			static class node implements Comparable<node>
	 
			{
				Integer x, y, z;
				node(int x,int y, int z)
				{
					this.x=x;
					this.y=y;
					this.z=z;
				}
				
				public int compareTo(pair o) {
					int result = x.compareTo(o.x);
					if(result==0)
						result = y.compareTo(o.y);
					if(result==0)
						result = z.compareTo(z); 
					return result;
				}
	 
				@Override
				public int compareTo(node o) {
					// TODO Auto-generated method stub
					return 0;
				}  
			}
			*/
		}
		
			
		
		