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

public class A {
    static class Node implements Comparable<Node>{
        long price;
        long cap;
        public Node(long price, long cap){
            this.price=price;
            this.cap=cap;
        }
        public int compareTo(Node c){
            return Long.compare(this.cap,c.cap);
        }
        @Override
        public boolean equals(Object o){
            if(o instanceof Node){
                Node c = (Node)o;

            }
            return false;
        }
    }
    //public static PrintWriter pw;
    public static PrintWriter pw = new PrintWriter(System.out);

    public static void solve() throws IOException {
//	pw=new PrintWriter(new FileWriter("C:\\Users\\shree\\Downloads\\small_output_in"));
        FastReader sc = new FastReader();
        int n =sc.I(); int k=sc.I();
        long s=sc.L(); long t=sc.L();
        Node p[]=new Node[n];
        for(int i=0;i<n;i++){
            long price=sc.L(); long cap=sc.L();
            p[i]=new Node(price,cap);
        }

        gas=new long[k];
        for(int i=0;i<k;i++) gas[i]=sc.L();
        Arrays.sort(gas);
        long ans=Long.MAX_VALUE;
        long l=0,h=(long)1e9;
        while(l<=h){
            long cap=(l+h)/2;
            if(can(cap,k,s,t)){
                for(int i=0;i<n;i++){
                    if(p[i].cap>=cap) ans=Math.min(ans,p[i].price);
                }
                h=cap-1;
            }else l=cap+1;

        }
        if(ans==Long.MAX_VALUE) pw.println(-1);
        else
        pw.println(ans);
        pw.close();


    }
static long gas[];
    static boolean can(long cap,int k,long s,long time){
        long prev=0;
        long tme=0;
        for(int i=0;i<k;i++){
            long d=gas[i]-prev;
            if(cap<d)return false;
            long dfast=Math.min(d,cap-d);
            tme+=dfast+2*(d-dfast);
            prev=gas[i];
        }
        long d=s-prev;
        if(cap<d)return false;
        long dfast=Math.min(d,cap-d);
        tme+=dfast+2*(d-dfast);
        if(tme>time) return false;
        return true;
    }
    public static void main(String[] args) {
        new Thread(null, new Runnable() {
            public void run() {
                try {

                    solve();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "1", 1 << 26).start();

    }

    static BufferedReader br;
    static long M = (long) 1e9 + 7;

    static class FastReader {

        StringTokenizer st;

        public FastReader() throws FileNotFoundException {
            //br=new BufferedReader(new FileReader("C:\\Users\\shree\\Downloads\\B-small-practice.in"));
            br = new BufferedReader(new InputStreamReader(System.in));

        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int I() {
            return Integer.parseInt(next());
        }

        long L() {
            return Long.parseLong(next());
        }

        double D() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public boolean hasNext() throws IOException {
            while (st == null || !st.hasMoreTokens()) {
                String s = br.readLine();
                if (s == null) {
                    return false;
                }
                st = new StringTokenizer(s);
            }
            return true;
        }

    }
}