Problem: problem

You are playing with J using the Midakuji. The Amida lottery consists of n vertical bars and m horizontal bars. The vertical bars are numbered from 1 to n in order from the left, and the vertical bar i The positive integer si is written at the bottom of.

<image>

Figure 3-1 Example of Amidakuji (n = 4, m = 5, s1 = 20, s2 = 80, s3 = 100, s4 = 50)

The integer written at the bottom of the vertical bar i, which is reached by following the path from the top of the vertical bar i, is the score when the vertical bar i is selected. For example, in Fig. 3-1 the vertical bar 1 is selected. And the score is 80 points, and if the vertical bar 2 is selected, the score is 100 points.

<image>

Figure 3-2 Example of how to follow the road

Mr. J decides to choose a series of k books from vertical bar 1 to vertical bar k. The total score when selecting those k vertical bars is J's score. However, you are in the Amidakuji You can select one horizontal bar and delete that horizontal bar from the Amidakuji. (You do not have to delete it.) If you delete one horizontal bar, the vertical bar in the deleted Amidakuji will be displayed vertically. J's score is the total of the points when selecting k consecutive vertical bars from bar 1 to vertical bar k.

Given the shape of the Amida lottery and the number of vertical bars k that J chooses as input, create a program that finds the minimum value of J's score.



input

The input consists of multiple datasets. Each dataset is given in the following format.

On the first line, four integers n, m, h, k are written separated by blanks. N (2 ≤ n ≤ 1000) is the number of vertical bars, and m (1 ≤ m ≤ 100000) is the horizontal bar. H (2 ≤ h ≤ 1000) represents the length of the vertical bar, and k (1 ≤ k ≤ n) represents the number of vertical bars you choose.

The following n lines contain the score written at the bottom of the vertical bar. The first line (1 ≤ i ≤ n) contains the positive integer si. Also, s1 + s2 + ... + sn ≤ 2000000000 = 2 × 109.

The following m lines indicate the position of the horizontal bar. The horizontal bars are numbered from 1 to m. The first line (1 ≤ i ≤ m) is the horizontal bar i. The two integers ai, bi (1 ≤ ai ≤ n --1, 1 ≤ bi ≤ h --1) representing the position are separated by blanks, and the horizontal bar i connects the vertical bar ai and the vertical bar ai + 1. , Indicates that the distance from the top edge of the horizontal bar i is bi. However, no two horizontal bars share an endpoint.

Of the scoring data, 20% of the points will have the lowest score for Mr. J if the horizontal bar is not deleted. Also, 30% of the points will satisfy n ≤ 20, m ≤ 30, h ≤ 10. 60% of the points are m ≤ 1000.

The end of the input is indicated by a line containing four zeros. The number of datasets does not exceed 10.

output

For each dataset, output the minimum score of Mr. J on one line.

Examples

Input

4 5 7 2
20
80
100
50
1 1
2 6
2 3
1 5
3 1
2 2 5 1
10
20
1 1
1 3
0 0 0 0


Output

100
10


Input

None


Output

None

Solution (in CPP):

Solution:
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstring>
using namespace std;

#define MAX_N 1020

long long n, m, h, K, a, b, s[MAX_N], goal2[MAX_N];
vector<long long>x[MAX_N];
vector<long long> goal[MAX_N];
vector<long long> y[MAX_N][500][2];

long long amida[MAX_N][500][2];
long long amida2[MAX_N][MAX_N];

void _memset() {
	for (int i = 0; i < MAX_N; i++) {
		x[i].clear();
		goal[i].clear();
		for (int j = 0; j < MAX_N; j++) {
			y[i][j][0].clear();
			y[i][j][1].clear();
		}
	}
	memset(goal2, 0, sizeof(goal2));
	memset(amida, 0, sizeof(amida));
	memset(amida2, 0, sizeof(amida2));
	memset(s, 0, sizeof(s));
}

long long AMIDA2(long long P,long long H) {
	long long L = 0, M = 1145141919810LL, D = 0;
	while (true)
	{
		M = 1145141919810LL;
		D = amida2[P][H];

		if (x[P].size() > D) {
			M = x[P][D];
			L = 0;
		}

		D = amida2[P - 1][H];

		if (x[P - 1].size() > D) {
			if (x[P - 1][D] <= M) {
				M = x[P - 1][D];
				L = 1;
			}
		}

		if (M >= 1145141919) {
			goto E;
		}
		if (L == 0) { P++; H = M; }
		else { P--; H = M; }

	}
E:;
	return P;
}

void AMIDA() {

	for (int i = 1; i <= n; i++) {
		for (int g = 0; g < x[i].size(); g++) {
			amida[i][g][0] = AMIDA2(i, x[i][g] - 1);
			amida[i][g][1] = AMIDA2(i + 1, x[i][g] - 1);
		}
	}

}

long long search() {
	long long minx2 = 0, sum = 0;

	AMIDA();

	for (int i = 1; i <= n; i++) {
		for (int j = 0; j < x[i].size(); j++) {
			sum = 0;
			long long a1 = s[amida[i][j][0]];
			long long a2 = s[amida[i][j][1]];

			for (int k = 0; k < y[i][j][0].size(); k++) {
				if (y[i][j][0][k] <= K) {
					sum += a2 - a1;
				}
			}

			for (int k = 0; k < y[i][j][1].size(); k++) {
				if (y[i][j][1][k] <= K) {
					sum += a1 - a2;
				}
			}

			minx2 = min(minx2, sum);
		}
	}

	return minx2;
}

long long score() {

	long long minx = 0LL;

	//hajime.
	for (int i = 1; i <= K; i++)
	{
		long long P = i, H = 0, M = 1145141919810LL, L = 0, Q1 = 0, Q2 = 0;

		while (true)
		{
			M = 1145141919810LL;
			for (int j = 0; j < x[P].size(); j++)
			{
				if (x[P][j] > H) {
					Q1 = j;
					M = x[P][j];
					L = 0;
					break;
				}
			}

			for (int j = 0; j < x[P - 1].size(); j++) {
				if (x[P - 1][j] > H) {
					if (x[P - 1][j] <= M) {
						Q2 = j;
						M = x[P - 1][j];
						L = 1;
					}
					break;
				}
			}

			if (M >= 1145141919) {
				goto E;
			}
			if (L == 0) { y[P][Q1][0].push_back(i); P++; H = M; }
			else { y[P - 1][Q2][1].push_back(i); P--; H = M; }

		}
	E:;
		goal[P].push_back(i);
		goal2[i] = P;
	}

	for (int i = 1; i <= n; i++) {
		minx += s[i] * goal[i].size();
	}

	return minx + search();
}

void amidakuji() {
	int cnt;
	for (int i = 1; i <= n; i++) {
		cnt = 0;
		for (int j = 0; j < MAX_N; j++) {
			if (x[i].size() != cnt) {
				if (x[i][cnt] == j) {
					cnt++;
				}
			}
			amida2[i][j] = cnt;
		}
	}
}

int main() {
	while (true) {
		_memset();
		cin >> n >> m >> h >> K;
		if (n == 0 && m == 0 && h == 0 && K == 0) { break; }
		for (int i = 1; i <= n; i++) {
			cin >> s[i];
		}
		for (int i = 0; i < m; i++) {
			cin >> a >> b;
			x[a].push_back(b);
		}
		for (int i = 0; i <= n; i++) {
			sort(x[i].begin(), x[i].end());
		}

		amidakuji();

		cout << score() << endl;
	}
	return 0;
}