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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Random;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        static final int inf = 1000000000;
        static final double eps = 1e-6;

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt(), k = in.nextInt(), s = in.nextInt(), t = in.nextInt();
            HashMap<Integer, Integer> prices = new HashMap<>();
            int[] capacities = new int[n];
            for (int i = 0; i < n; ++i) {
                int price = in.nextInt(), capacity = in.nextInt();
                if (!prices.containsKey(capacity)) {
                    prices.put(capacity, price);
                } else {
                    prices.put(capacity, Math.min(prices.get(capacity), price));
                }
                capacities[i] = capacity;
            }
            SafeSort.sort(capacities);
            int[] stations = new int[k + 1];
            for (int i = 0; i < k; ++i) stations[i] = in.nextInt();
            stations[k] = s;
            SafeSort.sort(stations);
            int l = 0, r = n - 1;
            int minAllowedCapacity = inf;
            boolean some = false;
            while (l <= r) {
                int h = (l + r) / 2;
                if (can(stations, t, capacities[h])) {
                    minAllowedCapacity = Math.min(minAllowedCapacity, h);
                    r = h - 1;
                    some = true;
                } else {
                    l = h + 1;
                }
            }
            if (some) {
                int ans = inf;
                for (int i = minAllowedCapacity; i < n; ++i)
                    ans = Math.min(ans, prices.get(capacities[i]));
                out.println(ans);
            } else {
                out.println(-1);
            }
        }

        private boolean can(int[] stations, int t, int capacity) {
            double curt = 0L;
            int last = 0;
            for (int station : stations) {
                int distance = station - last;
                if (distance > capacity) return false;
                double requires = calc(distance, capacity);
                curt += requires;
                last = station;
            }
            return curt - 1024.0 * eps <= t;
        }

        private double calc(double distance, double capacity) {
            double l = 0.0, r = distance;
            double ans = 0.0;
            while (Math.abs(l - r) > eps) {
                double h = (l + r) / 2.0;
                double q = distance - h;
                if (2.0 * h + q <= capacity) {
                    ans = Math.max(ans, h);
                    l = h + eps;
                } else {
                    r = h - eps;
                }
            }
            return ans + 2.0 * (distance - ans);
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            String CR = "Class taken from Petr Mitrichev's source code";
            reader = new BufferedReader(new InputStreamReader(stream), 65536 / 2);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }

    static class SafeSort {
        public static void sort(int[] arr) {
            Random random = new Random();
            for (int i = 0; i < arr.length; ++i) {
                int i1 = Math.abs(random.nextInt()) % arr.length;
                int i2 = Math.abs(random.nextInt()) % arr.length;
                int tmp = arr[i1];
                arr[i1] = arr[i2];
                arr[i2] = tmp;
            }
            Arrays.sort(arr);
        }

    }
}

