#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using PII = pair<int, int>;
template <typename T, typename Add = std::plus<T>,
          typename Mul = std::multiplies<T>>
struct Matrix {
  std::vector<std::vector<T>> D;
  Matrix(size_t m, size_t n) {
    D.resize(m);
    for (size_t i = 0; i < m; ++i) {
      D[i].resize(n);
    }
  }
  size_t m() const { return D.size(); }
  size_t n() const { return m() == 0 ? 0 : D[0].size(); }
  std::vector<T>& operator[](int i) { return D[i]; }
  Matrix<T, Add, Mul> operator*(const Matrix<T, Add, Mul>& that) const {
    assert(n() == that.m());
    Matrix<T, Add, Mul> r(m(), that.n());
    for (size_t i = 0; i < m(); ++i) {
      for (size_t j = 0; j < that.n(); ++j) {
        for (size_t k = 0; k < n(); ++k) {
          T tmp = Mul()(D[i][k], that.D[k][j]);
          r[i][j] = k == 0 ? tmp : Add()(r[i][j], tmp);
        }
      }
    }
    return r;
  }
  Matrix<T, Add, Mul> operator^(int k) const {
    assert(k >= 0);
    assert(m() == n());
    Matrix<T, Add, Mul> r(1, 1);
    bool initial = true;
    auto t = *this;
    while (k) {
      if (k & 1) {
        r = initial ? t : r * t;
        initial = false;
      }
      t = t * t;
      k >>= 1;
    }
    return r;
  }
  void print() const {
    for (size_t i = 0; i < m(); ++i) {
      for (size_t j = 0; j < n(); ++j) {
        std::cout << D[i][j] << ' ';
      }
      std::cout << std::endl;
    }
  }
};
const LL INF = 1LL << 61;
LL calcJumpCost(const bitset<10>& from, const bitset<10>& to, int Cost[]) {
  assert(from.count() == to.count());
  auto shift = to << 1;
  auto tmp = from ^ shift;
  if (tmp.count() == 0)
    return 0;
  else if (tmp.count() != 2)
    return INF;
  else {
    int p = 0;
    while (!from.test(p)) p++;
    if (!tmp.test(p)) return INF;
    tmp.reset(p);
    int q = 0;
    while (!tmp.test(q)) q++;
    if (q < p) return INF;
    return Cost[q - p];
  }
}
template <typename T>
struct Min {
  T operator()(T a, T b) { return min({a, b, INF}); }
};
Matrix<LL, Min<LL>, plus<LL>> buildMatrix(const vector<bitset<10>>& V,
                                          int C[]) {
  Matrix<LL, Min<LL>, plus<LL>> R(V.size(), V.size());
  for (size_t i = 0; i < V.size(); i++) {
    for (size_t j = 0; j < V.size(); j++) {
      auto from = V[i];
      auto to = V[j];
      R[i][j] = calcJumpCost(from, to, C);
    }
  }
  return R;
}
int x, k, n, q;
int C[10];
map<int, int> Special;
int main() {
  scanf("%d%d%d%d", &x, &k, &n, &q);
  vector<bitset<10>> V;
  for (int state = 1; state < (1 << k); state++) {
    auto bs = bitset<10>(state);
    if (int(bs.count()) != x) continue;
    V.push_back(bs);
  }
  for (int i = (1); i <= (k); ++i) scanf("%d", &C[i]);
  LL ans = 0;
  set<int> S;
  for (int i = (1); i <= (q); ++i) {
    int p, w;
    scanf("%d%d", &p, &w);
    if (p >= n - x + 1) {
      ans += w;
      continue;
    }
    for (int j = p - k; j <= p; j++) {
      if (j <= 1) continue;
      S.insert(j);
    }
    Special[p] = w;
  }
  S.insert(n - x + 1);
  auto Mul = buildMatrix(V, C);
  auto A = Mul;
  A.D.resize(1);
  for (size_t i = 0; i < A.n(); ++i) A[0][i] = INF;
  A[0][0] = 0;
  int pre = 1;
  for (auto cur : S) {
    if (cur == pre + 1) {
      auto B = A;
      for (int j = 0; j < int(V.size()); j++) {
        B[0][j] = INF;
        for (int i = 0; i < int(V.size()); i++) {
          LL update = A[0][i];
          auto from = V[i];
          auto to = V[j];
          update += calcJumpCost(from, to, C);
          auto tmp = (from ^ (to << 1)) & (~from);
          for (int k = 0; k < 10; k++) {
            if (tmp.test(k) && Special.find(k + pre) != Special.end()) {
              update += Special[k + pre];
              break;
            }
          }
          B[0][j] = min(B[0][j], update);
        }
      }
      A = B;
    } else {
      A = A * (Mul ^ (cur - pre));
    }
    pre = cur;
  }
  cout << A[0][0] + ans << endl;
  return 0;
}
