#include <bits/stdc++.h>

using namespace std;

#ifdef LOCAL
template<class... T> void dbg(T... x) { char e{}; ((cerr << e << x, e = ' '), ...); }
template<class T> void org(T l, T r) { while (l != r) cerr << ' ' << *l++; cerr << '\n'; }
#define debug(x...) dbg(#x, '=', x, '\n')
#define olist(x...) dbg(#x, '='), org(x)
#else
#define debug(...) ((void)0)
#define olist(...) ((void)0)
#endif
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define ff first
#define ss second

using i64 = long long;
using u64 = unsigned long long;
using i128 = __int128;
using u128 = unsigned __int128;

constexpr int inf = 1e9;
constexpr int mod = 998244353;

template<class T> bool chmin(T &a, T b) { return (b < a and (a = b, true)); }
template<class T> bool chmax(T &a, T b) { return (a < b and (a = b, true)); }
template<class... T> int add(T... x) { int t{}; return (((t += x) %= mod), ...), t; }
template<class... T> int mul(T... x) { i64 t{1}; return (((t *= x) %= mod), ...), t; }

void solve() {
    int n, m, K, P;
    cin >> n >> m >> K >> P;

    vector<i64> dis(n, 1);
    vector<bool> blk(n);
    for (int i = 0; i < m; i++) {
        int c, t;
        cin >> c >> t;
        c--;
        dis[c] += t;
        blk[c] = true;
    }
    partial_sum(all(dis), dis.begin());
    
    vector<bool> fan(n);
    for (int i = 0; i < K; i++) {
        int x;
        cin >> x;
        fan[x - 1] = true;
    }

    vector<i64> D;
    vector<bool> F;
    for (int i = 0; i < n; i++)
        if (!blk[i]) {
            F.push_back(fan[i]);
            D.push_back(dis[i]);
        }

    n = F.size();
    const int H = __lg(n);
    
    for (int i = 0; i < n * 2; i++) {
        F.push_back(F[i]);
        D.push_back(D[i] + dis.back());
    }

    olist(all(F));
    olist(all(D));

    auto check = [&](i64 C) -> bool {
        vector<int> L(n * 3);
        vector<int> tag(n * 3 + 1, n * 3);
        for (int l = 0, r = 0; l < n * 3; l++) {
            while (r < n * 3 and r - l < n and D[r] - D[l] <= C) {
                L[r] = l;
                r++;
            }
            if (n <= l and l < n * 2 and F[l]) {
                chmin(tag[L[l]], min(L[l] + n, r));
            }
        }
        
        vector st(H + 1, vector<int>(n * 3 + 1, n * 3));
        for (int i = n * 3 - 1; i >= 0; i--) {
            chmin(tag[i], tag[i + 1]);
            st[0][i] = tag[i];
        }
        for (int i = 0; i + 1 < H + 1; i++)
            for (int j = 0; j < n * 3; j++) {
                st[i + 1][j] = st[i][st[i][j]];
            }
        for (int i = 0; i < n * 2; i++) {
            int p = i;
            int s = 0;
            for (int j = H; j >= 0; j--)
                if (st[j][p] <= i + n) {
                    p = st[j][p];
                    s += (1 << j);
                }
            if (s > P) return true;
        }
        return false;
    };

    i64 ans = *ranges::partition_point(views::iota(0ll, (i64)1e18), check);

    cout << ans << '\n';
    
}

signed main() {
    cin.tie(0)->sync_with_stdio(false);
    cin.exceptions(cin.failbit);
    
    int T = 1;
    // cin >> T;
    while (T--) {
        solve();
    }
    
    return 0;
}