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 rep(i, a, b) for (int i = (a); i <= int(b); i++)
#define per(i, a, b) for (int i = (a); i >= int(b); i--)
#define fi first
#define se second

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, ll> foo;

const int maxn = 3e4, maxm = 4 * maxn;

int T, n, c, q, a[maxn + 5];

ll delta[5][maxn + 5];

bool comp1(const foo &a, const foo &b) {
	return a.se < b.se;
}

bool comp2(foo x, foo y) {
	return a[x.fi.fi + x.fi.se] < a[y.fi.fi + y.fi.se];
}

template<class type>
struct my_deque {
	type q[2 * maxm + 10], *l, *r = l = q + maxm + 5;
	void init() {
		l = r = q + maxm + 5;
	}
	void push_back(type x) {
		*r++ = x;
	}
	void push_front(type x) {
		*--l = x;
	}
};

my_deque<foo> D[5];

ll ways(int n, int c) {
	if (n == 0) {
		return 1;
	}
	ll cur = 1, sum = 1;
	rep(i, 1, c) {
		cur *= (n - i);
		cur /= i;
		sum += cur;
	}
	return sum;
}

void prepare(my_deque<foo> &D) {
	for (foo *x = D.l + 1; x < D.r; x++) {
		x->se += (x - 1)->se;
	}
}

foo query(int x, int c, ll &k) {
	k += delta[c][x];
	foo *p = lower_bound(D[c].l, D[c].r, foo(pii(0, 0), k), comp1);
	assert(k <= p->se);
	return foo(p->fi, p == D[c].l ? 0ll : (p - 1)->se);
}

int main() {
	scanf("%d", &T);
	while (T --> 0) {
		scanf("%d %d %d", &n, &c, &q);
		rep(i, 1, n) {
			scanf("%d", &a[i]);
		}
		rep(i, 0, c) {
			D[i].init();
			D[i].push_back(foo(pii(0, 0), 1ll));
		}
		rep(k, 1, c) {
			memset(delta[k] + 1, 0, n << 3);
			per(i, n - 1, 1) {
				int cl = 0, cr = 0;
				rep(j, 1, min(n - i, k)) {
					foo x = foo(pii(i, j), ways(n - i - j, k - j));
					if (a[i + j] > a[i]) {
						D[k].push_back(x), cr++;
					} else {
						D[k].push_front(x), cl++;
						delta[k][i + 1] += x.se;
					}
				}
				sort(D[k].l, D[k].l + cl, comp2);
				sort(D[k].r - cr, D[k].r, comp2);
			}
			rep(i, 2, n) {
				delta[k][i] += delta[k][i - 1];
			}
			// puts("=====");
			// printf("%d\n", k);
			// for (foo *x = D[k].l; x < D[k].r; x++) {
			// 	printf("%d %d %lld\n", x->fi.fi, x->fi.se, x->se);
			// }
		}
		rep(k, 0, c) {
			prepare(D[k]);
		}
		ll lim = ways(n, c);
		for (int i; q --> 0; ) {
			ll j;
			scanf("%d %lld", &i, &j);
			if (j > lim) {
				puts("-1");
				continue;
			}
			int s = 1, l = c;
			while (s <= n) {
				foo x = query(s, l, j);
				pii p = x.fi;
				if (p == pii(0, 0) || i < p.fi) {
					printf("%d\n", a[i]);
					goto next_query;
				}
				if (i <= p.fi + p.se) {
					printf("%d\n", a[2 * p.fi + p.se - i]);
					goto next_query;
				}
				s = p.fi + p.se + 1;
				j -= x.se;
				l -= p.se;
			}
			next_query: void();
		}
	}
	return 0;
}