package main

import (
	"fmt"
	"math/bits"
	"sort"
)

const INF int64 = 1e18

func add(a, b int64) int64 {
	if a >= INF/2 || b >= INF/2 {
		return INF
	}
	return a + b
}

func mulVecMat(V []int64, M [][]int64) []int64 {
	D := len(V)
	res := make([]int64, D)
	for i := range res {
		res[i] = INF
	}
	for u := 0; u < D; u++ {
		if V[u] >= INF/2 {
			continue
		}
		for v := 0; v < D; v++ {
			val := add(V[u], M[u][v])
			if val < res[v] {
				res[v] = val
			}
		}
	}
	return res
}

func main() {
	var x, k, n, q int
	if _, err := fmt.Scan(&x, &k, &n, &q); err != nil {
		return
	}

	c := make([]int64, k+1)
	for i := 1; i <= k; i++ {
		fmt.Scan(&c[i])
	}

	specialStones := make(map[int]int64)
	for i := 0; i < q; i++ {
		var p int
		var wp int64
		fmt.Scan(&p, &wp)
		specialStones[p] = wp
	}

	var states []int
	var maskToIndex [256]int
	for i := 0; i < (1 << k); i++ {
		if bits.OnesCount(uint(i)) == x {
			maskToIndex[i] = len(states)
			states = append(states, i)
		}
	}
	D := len(states)

	T := make([][]int64, D)
	for i := range T {
		T[i] = make([]int64, D)
		for j := range T[i] {
			T[i][j] = INF
		}
	}

	for u := 0; u < D; u++ {
		M := states[u]
		if M&1 == 0 {
			M_prime := M >> 1
			v := maskToIndex[M_prime]
			T[u][v] = 0
		} else {
			for j := 1; j <= k; j++ {
				if j == k || (M&(1<<j)) == 0 {
					M_prime := (M >> 1) | (1 << (j - 1))
					v := maskToIndex[M_prime]
					if c[j] < T[u][v] {
						T[u][v] = c[j]
					}
				}
			}
		}
	}

	var T_powers [][][]int64
	T_powers = append(T_powers, T)
	for p := 1; p < 30; p++ {
		prev := T_powers[p-1]
		next := make([][]int64, D)
		for i := range next {
			next[i] = make([]int64, D)
			for j := range next[i] {
				next[i][j] = INF
				for w := 0; w < D; w++ {
					val := add(prev[i][w], prev[w][j])
					if val < next[i][j] {
						next[i][j] = val
					}
				}
			}
		}
		T_powers = append(T_powers, next)
	}

	advanceBy := func(V []int64, m int) []int64 {
		for p := 0; p < 30; p++ {
			if (m & (1 << p)) != 0 {
				V = mulVecMat(V, T_powers[p])
			}
		}
		return V
	}

	specialStepsSet := make(map[int]bool)
	for p := range specialStones {
		for i := p - k; i <= p - 1; i++ {
			if i >= 1 && i <= n-x {
				specialStepsSet[i] = true
			}
		}
	}
	var specialSteps []int
	for i := range specialStepsSet {
		specialSteps = append(specialSteps, i)
	}
	sort.Ints(specialSteps)

	V := make([]int64, D)
	for i := range V {
		V[i] = INF
	}
	initMask := (1 << x) - 1
	V[maskToIndex[initMask]] = 0

	curr := 1
	for _, s := range specialSteps {
		if s > curr {
			V = advanceBy(V, s-curr)
			curr = s
		}

		V_new := make([]int64, D)
		for i := range V_new {
			V_new[i] = INF
		}
		for u := 0; u < D; u++ {
			if V[u] >= INF/2 {
				continue
			}
			M := states[u]
			if M&1 == 0 {
				M_prime := M >> 1
				v := maskToIndex[M_prime]
				if V[u] < V_new[v] {
					V_new[v] = V[u]
				}
			} else {
				for j := 1; j <= k; j++ {
					if j == k || (M&(1<<j)) == 0 {
						M_prime := (M >> 1) | (1 << (j - 1))
						v := maskToIndex[M_prime]
						cost := add(V[u], c[j])
						dest := s + j
						if wp, exists := specialStones[dest]; exists {
							cost = add(cost, wp)
						}
						if cost < V_new[v] {
							V_new[v] = cost
						}
					}
				}
			}
		}
		V = V_new
		curr = s + 1
	}

	if curr <= n-x {
		V = advanceBy(V, n-x-curr+1)
	}

	ans := V[maskToIndex[initMask]]
	fmt.Println(ans)
}