1
10 2 20
8 5 2 4 10 3 9 7 1 6
5 10
3 17
6 31
3 46
10 42
7 19
9 36
7 3
3 13
8 32
10 25
9 34
10 34
6 33
3 9
2 17
4 5
10 44
9 15
5 40
 1
47 1 47
40 45 19 10 44 33 47 12 2 46 16 23 3 14 21 28 31 42 22 18 35 38 24 25 36 32 4 34 5 20 37 39 6 9 1 7 29 8 17 27 30 11 13 41 15 43 26
39 25
41 24
32 30
10 6
30 13
24 35
41 17
31 31
9 44
21 8
43 23
8 5
29 13
8 4
47 20
22 10
37 27
17 39
43 23
14 42
46 19
43 24
30 31
24 35
31 13
31 32
20 9
3 2
20 9
14 7
7 3
21 36
32 30
47 19
11 43
6 2
31 31
26 12
47 20
2 1
40 24
16 40
45 21
36 28
36 28
17 38
30 31
 1
1 1 4
1
1 1
1 2
1 3
1 4
 1
10 1 1
10 4 6 5 7 9 8 1 3 2
6 10

3
2
7
10
6
7
7
7
5
1
6
6
1
9
4
4
4
1
1
3
 27
27
37
16
20
24
11
20
46
35
11
2
34
47
26
24
7
28
11
3
26
13
37
24
37
37
22
10
22
14
47
38
37
43
23
33
20
4
26
19
30
21
43
1
1
42
37
 1
-1
-1
-1
 9

#include <bits/stdc++.h>
#define pb push_back
#define fi first
#define se second
#define sz(x) (int)x.size()
#define cat(x) cerr << #x << " = " << x << endl
 
using ll = long long;
using namespace std;

const int N = 1 << 17;

int n, c, q, p[N];
ll dp[N][5], L[N][5];
vector<int> per[N][5];

void solve() {
	scanf("%d%d%d", &n, &c, &q);
	for (int i = 1; i <= n; ++i)
		scanf("%d", p + i);
	fill(dp[n + 1], dp[n + 1] + c + 1, 1);
	for (int i = n; i >= 1; --i)
		for (int j = 0; j <= c; ++j) {
			dp[i][j] = 0;
			for (int k = 0; k <= j && i + k <= n; ++k)
				dp[i][j] = dp[i][j] + dp[i + k + 1][j - k];
		}
	for (int i = 1; i <= n + 1; ++i) fill(L[i], L[i] + c + 1, 0);
	for (int i = n; i >= 1; --i) 
		for (int j = 0; j <= c; ++j) {
			vector<int> &P = per[i][j];
			P.resize(min(j, n - i) + 1);
			iota(P.begin(), P.end(), 0);
			sort(P.begin(), P.end(), [&](int a, int b) {
				return p[i + a] < p[i + b];
			});
			for (int k = 0; k < P.size(); ++k) {
				if (P[k] == 0) {
					L[i][j] += L[i + 1][j];
					break;
				}
				L[i][j] += dp[i + P[k] + 1][j - P[k]];
			}
			assert(L[i][j] >= 0);
		}
	while (q--) {
		int pos; ll k;
		scanf("%d%lld", &pos, &k);
		if (k > dp[1][c]) {
			printf("-1\n");
			continue;
		}
		int v = 1, cc = c;
		while (true) {
			for (int i = __lg(n); i >= 0; --i) {
				int u = v + (1 << i);
				if (u > n + 1) continue;
				ll cnt = L[v][cc] - L[u][cc];
				if (cnt >= k || cnt + dp[u][cc] < k) continue;
				v = u;
			}
			if (pos < v) {
				printf("%d\n", p[pos]);
				break;
			}
			bool done = false;
			for (auto j : per[v][cc]) {
				if (dp[v + j + 1][cc - j] < k) {
					k -= dp[v + j + 1][cc - j];
					continue;
				}
				if (v <= pos && pos <= v + j) {
					done = true;
					printf("%d\n", p[v + j - (pos - v)]);
				}
				cc -= j;
				v += j + 1;
				break;
			}
			if (done) break;
		}
	}
}

int main() {
	int t;
	scanf("%d", &t);
	while (t--)		
		solve();
	return 0;
}
