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>
using namespace std;
inline namespace Infinity {
inline namespace Constant {
constexpr const int eof = EOF;
constexpr const int maxint = INT_MAX;
constexpr const long long maxll = LLONG_MAX;
constexpr const double eps = DBL_EPSILON;
}  // namespace Constant
inline namespace TypeDefine {
using uint = unsigned int;
using ll = long long int;
using ull = unsigned long long int;
using ld = long double;
template <typename T = int>
using Pair = pair<T, T>;
template <typename T = int>
using PairList = vector<Pair<T>>;
template <typename T = vector<int>>
using Iter = typename T::iterator;
}  // namespace TypeDefine
inline namespace IO {
const char LF = '\n';
const char SP = ' ';
int dbl_prec = 10;
int ldbl_prec = 18;
inline void write(const int n) { printf("%d", n); }
inline void write(const unsigned n) { printf("%u", n); }
inline void write(const long long n) { printf("%" PRId64, n); }
inline void write(const unsigned long long n) { printf("%" PRIu64, n); }
inline void write(const double a) { printf("%.*f", dbl_prec, a); }
inline void write(const long double a) { printf("%.*Lf", ldbl_prec, a); }
inline void write(const char c) { printf("%c", c); }
inline void write(const char s[]) { printf("%s", s); }
inline void write(const string &s) { printf("%s", s.data()); }
template <typename T>
inline void writeSP(const T a) {
  write(a);
  write(SP);
}
template <typename T, typename U>
inline void write(const pair<T, U> &p) {
  writeSP(p.first);
  write(p.second);
}
template <class T>
inline void write(const T a) {
  for (auto i = a.begin(); i != a.end(); i++) {
    if (i != a.begin()) write(SP);
    write(*i);
  }
}
template <typename T>
inline void write(initializer_list<T> list) {
  for (auto i = list.begin(); i != list.end(); i++) {
    if (i != list.begin()) write(SP);
    write(*i);
  }
}
template <typename T>
inline void writer(T begin, T end) {
  for (write(*begin++); begin != end; ++begin) write(SP), write(*begin);
}
inline void writeln() { write(LF); }
inline void writeSP() { write(SP); }
template <typename T>
inline void writeln(const T &a) {
  write(a);
  write(LF);
}
template <typename T>
inline void writeln(initializer_list<T> list) {
  for (auto i = list.begin(); i != list.end(); i++) {
    if (i != list.begin()) write(SP);
    write(*i);
  }
  write(LF);
}
template <class T>
inline void writelns(const T &a) {
  for (auto n : a) writeln(n);
}
template <typename T, typename... types>
inline void write(const T &a, const types &...args) {
  write(a);
  write(args...);
}
template <typename... types>
inline void writeln(const types &...args) {
  write(args...);
  write(LF);
}
template <typename... types>
inline void writeSP(const types &...args) {
  write(args...);
  write(SP);
}
inline void writelnYN(bool b) { writeln(b ? "YES" : "NO"); }
inline void writelnyn(bool b) { writeln(b ? "Yes" : "No"); }
string caseN(int n, bool sharp = true, bool space = true) {
  return string("Case ") + (sharp ? "#" : "") + to_string(n) + ":" +
         (space ? " " : "");
}
inline int read(int &n) { return scanf("%d", &n); }
inline int read(long long &n) { return scanf("%" SCNd64, &n); }
template <typename T, typename... types>
inline int read(T &n, types &...args) {
  return read(n) == eof ? eof : read(args...) + 1;
}
inline char getcc() {
  char c;
  do c = getchar();
  while (isspace(c));
  return c;
}
inline int getint() {
  int n;
  read(n);
  return n;
}
inline long long getll() {
  long long n;
  read(n);
  return n;
}
inline double getdbl() {
  double n;
  scanf("%lf", &n);
  return n;
}
inline pair<int, int> getpair() {
  pair<int, int> p;
  scanf("%d%d", &p.first, &p.second);
  return p;
}
inline vector<int> getints(int n) {
  vector<int> v(n);
  for (int &i : v) i = getint();
  return v;
}
inline vector<pair<int, int>> getpairs(int n) {
  vector<pair<int, int>> v(n);
  for (pair<int, int> &p : v) {
    p = getpair();
  }
  return v;
}
inline void read(string &str, unsigned size) {
  char s[++size];
  scanf("%s", s);
  str.assign(s);
}
inline string getstr(unsigned size = 0x100000) {
  string s;
  read(s, size);
  return s;
}
inline string getln(unsigned size = 0x100000) {
  char s[++size];
  scanf("%[^\n]", s);
  getchar();
  return s;
}
}  // namespace IO
inline namespace Miscelleneous {
inline constexpr int ctoi(const char c) { return c - '0'; }
inline constexpr char itoc(const int n) { return n + '0'; }
inline int dtoi(const double d) { return round(d); }
template <typename T>
inline constexpr bool in(T x, T l, T r) {
  return l <= x && x <= r;
}
template <typename T>
inline constexpr T tristate(int val, T nag, T zero, T pos) {
  return val > 0 ? pos : val < 0 ? nag : zero;
}
template <class T>
inline int size(const T &a) {
  return a.size();
}
template <class T>
inline void sort(T &a) {
  sort(a.begin(), a.end());
}
template <class T1, class T2>
inline void sort(T1 &a, T2 comp) {
  sort(a.begin(), a.end(), comp);
}
template <class T1, typename T2>
inline int lbound(const T1 &a, const T2 k) {
  return lower_bound(a.begin(), a.end(), k) - a.begin();
}
template <class T1, typename T2>
inline int ubound(const T1 &a, const T2 k) {
  return upper_bound(a.begin(), a.end(), k) - a.begin();
}
template <class T1, class T2>
inline int count(T1 &a, T2 k) {
  return ubound(a, k) - lbound(a, k);
}
template <typename T>
inline void clear(T &a) {
  memset(a, 0, sizeof a);
}
template <typename T>
T gcd(T a, T b) {
  while (b) {
    T t = a % b;
    a = b;
    b = t;
  }
  return a;
}
template <typename T>
T lcm(T a, T b) {
  return a / gcd(a, b) * b;
}
long long qpow(long long a, long long b, long long c) {
  return b ? qpow(a * a % c, b >> 1, c) * (b & 1 ? a : 1) % c : 1;
}
template <typename T>
T exGcd(T a, T b, T &x, T &y) {
  T d = a;
  if (b) {
    d = exGcd(b, a % b, y, x);
    y -= a / b * x;
  } else {
    x = 1;
    y = 0;
  }
  return d;
}
template <typename T>
inline constexpr T mps(T l, T r, T k) {
  return ((r - (r % k + k) % k) - (l + (k - l % k) % k)) / k + 1;
}
template <typename T>
inline constexpr T sgn(T a) {
  return a ? a > 0 ? 1 : -1 : 0;
}
template <typename T>
inline constexpr T sq(T a) {
  return a * a;
}
template <typename T>
inline constexpr bool odd(T a) {
  return bool(a % 2);
}
template <typename T>
inline constexpr bool even(T a) {
  return !bool(a % 2);
}
template <typename T1, typename T2>
inline constexpr T1 smod(T1 x, T2 m) {
  return x > m ? x - m : x + m < m ? x + m : x;
}
template <typename T>
inline constexpr T lmiddle(T first, T last) {
  return first + (last - first) / 2;
}
template <typename T>
inline constexpr T rmiddle(T first, T last) {
  return last - (last - first) / 2;
}
template <typename T, typename F>
T dichotomy(T l, T r, F check, T prec = 1) {
  while (r - l > prec) {
    T m = lmiddle(l, r);
    (check(m) ? l : r) = m;
  }
  return l;
}
template <typename T, typename F>
T dichotomy2(T l, T r, F check, T prec = 1) {
  while (r - l > prec) {
    T m = rmiddle(l, r);
    (check(m) ? r : l) = m;
  }
  return r;
}
bool contains(const string &s, const string &t) {
  return s.find(t) != string::npos;
}
template <typename T>
bool contains(const T &s, typename T::value_type t) {
  for (typename T::value_type c : s)
    if (c == t) return true;
  return false;
}
template <typename T>
bool contains(const initializer_list<T> s, T t) {
  return find(s.begin(), s.end(), t) != s.end();
}
}  // namespace Miscelleneous
}  // namespace Infinity
int main() {
  int n = getint(), k = getint(), s = getint(), t = getint();
  PairList<int> p = getpairs(n);
  vector<int> g = getints(k);
  sort(g);
  vector<int> tt{g.front(), s - g.back()};
  adjacent_difference(g.begin(), g.end(), back_inserter(tt));
  sort(p, [](const pair<int, int> &a, const pair<int, int> &b) {
    return a.first < b.first;
  });
  for (int i = 1; i < n; i++) {
    p[i].second = max(p[i].second, p[i - 1].second);
  }
  int st = 0;
  for (int k : tt) {
    st += 3 * k - p[n - 1].second;
  }
  if (st > t) {
    writeln(-1);
  } else {
    writeln(p[dichotomy2(-1, n - 1, [&](int id) {
              int st = 0;
              for (int k : tt) {
                st += 3 * k - p[id].second;
              }
              return st < t;
            })].first);
  }
  return 0;
}
