#include <bits/stdc++.h>
using namespace std;

#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
#define chmax(a,b) (a<(b)?(a=b,1):0)
#define chmin(a,b) (a>(b)?(a=b,1):0)
#define valid(y,x,h,w) (0<=y&&y<h&&0<=x&&x<w)
const int INF = 1<<29;
const double EPS = 1e-8;
const double PI = acos(-1);
typedef pair<int,int> pii;
typedef long long ll;
typedef pair<ll, ll> pll;

struct CHT {
  static const ll I = LLONG_MAX;
  CHT() {
    // 番兵
    S.insert({L(I,0), L(-I,0)});
    C.insert(cp(L(I,0),L(-I,0)));
  }
  // |a|,|b|<I/2  |ab| < LONG_LONG_MAX/2
  void add(ll a, ll b) {
    const L p(a,b);
    It pos = S.insert(p).first;
    if (check(*it_m1(pos), p, *it_p1(pos))) {
      S.erase(pos);
      return;
    }
    C.erase(cp(*it_m1(pos), *it_p1(pos)));
    {
      It it = it_m1(pos);
      while(it!=S.begin() && check(*it_m1(it), *it, p)) --it;
      erase(it, pos);
      S.erase(++it,pos);
      pos = S.find(p);
    }
    {
      It it = it_p1(pos);
      while(it_p1(it)!=S.end() && check(p,*it, *it_p1(it))) ++it;
      erase(++pos, it);
      S.erase(pos, it);
      pos = S.find(p);
    }
    C.insert(cp(*it_m1(pos), *pos));
    C.insert(cp(*pos, *it_p1(pos)));
  }
  ll query(ll x) {
    if ((int)S.size()==2) return 1LL<<55;
    const L &p = (--C.lower_bound(CP(x,1,L(0,0))))->p;
    return p.a*x + p.b;
  }

private:

  template<class T>  inline T it_p1(T a) { return ++a; }
  template<class T>  inline T it_m1(T a) { return --a; }
  struct L {
    ll a, b;
    L(ll a, ll b) : a(a),b(b) {}
    bool operator<(const L &rhs) const {
      return a != rhs.a ? a > rhs.a : b < rhs.b;
    }
  };
  struct CP {
    ll n,d;
    L p;
    CP(ll _n, ll _d, const L &p) : n(_n),d(_d),p(p) {
      if (d < 0) { n *= -1; d *= -1; }
    };
    bool operator<(const CP &rhs) const {
      if (n == I || rhs.n == -I) return 0;
      if (n == -I || rhs.n == I) return 1;
      return n * rhs.d < rhs.n * d;
    }
  };
  set<L> S;
  typedef set<L>::iterator It;
  set<CP> C;

  void erase(It a, It b) {
    for (It it=a; it!=b; ++it)
      C.erase(cp(*it, *it_p1(it)));
  }
  CP cp(const L &p1, const L &p2) {
    if (p1.a == I) return CP(-I,1,p2);
    if (p2.a == -I) return CP(I,1,p2);
    return CP(p1.b-p2.b, p2.a-p1.a, p2);
  }
  bool check(const L &p1, const L &p2, const L &p3) {
    if (p1.a==p2.a && p1.b <= p2.b) return 1;
    if (p1.a == I || p3.a == -I) return 0;
    return (p2.a-p1.a)*(p3.b-p2.b) >= (p2.b-p1.b)*(p3.a-p2.a);
  }
};

ll p[10000];
ll c[10000];
ll dp[10001][101];

int main() {
  ll n,m,d,x;
  while(cin>>n>>m>>d>>x) {
    REP(i,n) {
      cin >> p[i];
    }
    REP(i,m) {
      int a, b;
      cin >> a >> b;
      if (b > 0) {
        // y = (x-a) + b = 0
        // x = a - b
        c[i] = a-b;
      } else {
        // y = -(x-a) + b = 0
        // x = a + b
        c[i] = a+b;
      }
    }
    sort(c,c+m);
    vector<CHT> cht(d+1);
    vector<ll> id(d+1,0);
    REP(i,n)REP(k,d+1)dp[i][k] = 1LL<<50;
    dp[0][0] = 0;
    while(id[0]<m&&c[id[0]]<p[0]) id[0]++;
    cht[0].add(m-id[0], dp[0][0]-p[0]*(m-id[0]));
    REP(i,n) {
      for (int k=d; k>=1; --k) {
        while(id[k]<m&&c[id[k]]+x*k<p[i]) id[k]++;
        dp[i][k] = cht[k-1].query(p[i]);
        // cout << dp[i][k] << "," << m-id[k] << " " ;
        cht[k].add(m-id[k], dp[i][k]-p[i]*(m-id[k]));

      }
      // cout << endl;
    }
    cout << *min_element(dp[n-1], dp[n-1]+d+1) << endl;
  }
}

Measured memory_bytes: 9612