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

#include <bits/stdc++.h>
class TaskA {
 public:
  struct Car {
    int cost, fuel;
  };
  void solve(std::istream& in, std::ostream& out) {
    int n, k, s, t;
    in >> n >> k >> s >> t;
    std::vector<Car> cars(n);
    for (int i = 0; i < n; i++) {
      in >> cars[i].cost >> cars[i].fuel;
    }
    std::sort(cars.begin(), cars.end(),
              [](Car a, Car b) { return a.cost < b.cost; });
    std::vector<int64_t> poses(k);
    for (int i = 0; i < k; i++) {
      in >> poses[i];
    }
    poses.push_back(s);
    std::sort(poses.begin(), poses.end());
    {
      std::vector<Car> good_cars;
      for (auto car : cars) {
        if (good_cars.empty() || good_cars.back().fuel < car.fuel) {
          good_cars.push_back(car);
        }
      }
      cars = good_cars;
      n = cars.size();
    }
    auto get_fast_jumps = [](int64_t distance, int64_t fuel) {
      int64_t l = 0, r = distance + 1;
      while (r - l > 1) {
        int64_t m = (l + r) / 2;
        int64_t result = 2 * m + (distance - m);
        if (result >= fuel)
          l = m;
        else
          r = m;
      }
      return l;
    };
    auto get_time = [&](Car car) {
      int64_t result_time = 0;
      int64_t current_pos = 0;
      for (auto pos : poses) {
        int64_t distance = pos - current_pos;
        if (distance > car.fuel) {
          return static_cast<int64_t>(-1);
        }
        int64_t fast_jumps = get_fast_jumps(distance, car.fuel);
        assert(fast_jumps >= 0 && fast_jumps <= distance);
        int64_t slow_jumps = distance - fast_jumps;
        result_time += fast_jumps;
        result_time += 2 * slow_jumps;
        current_pos = pos;
      }
      return result_time;
    };
    int l = -1, r = n;
    while (r - l > 1) {
      int m = (l + r) / 2;
      int64_t time = get_time(cars[m]);
      if (time == -1 || time > t)
        l = m;
      else
        r = m;
    }
    if (r == n) {
      out << -1 << "\n";
    } else {
      out << cars[r].cost << "\n";
    }
  }
};
int main() {
  TaskA solver;
  std::istream& in(std::cin);
  std::ostream& out(std::cout);
  solver.solve(in, out);
  return 0;
}
