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 ll long long
#define db long double
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define all(a) a.begin(), a.end()

using namespace std;

const int N = 30007;
const int M = 5;

struct Transition {
	int primary;
	int to;
	int coins;
};

bool cmp(Transition &x, Transition &y) {
	return (x.primary < y.primary);
}

vector<Transition> trans[N][M];
ll cnt[N][M];

const int LG = 17;

pair<ll, ll> what_state[N][M][LG];
pair<ll, ll> edges[N][M][LG];


void solve() {

	int n, c, q;
	cin >> n >> c >> q;

	vector<int> v(n);
	for (auto &x : v) {
		cin >> x;
		x--;
	}

	for (int i = n; i >= 0; --i) {
		for (int j = c; j >= 0; --j) {
			trans[i][j].clear();
			for (int take = 1; take + i <= n && take - 1 <= j; ++take) {
				int P = v[i + take - 1];
				trans[i][j].pb({P, i + take, j - (take - 1)});
			}
			sort(all(trans[i][j]), cmp);
			if (!trans[i][j].size()) {
				cnt[i][j] = 1;
				for (int e = 0; e < LG; ++e) {
					what_state[i][j][e] = mp(-1, -1);
					edges[i][j][e] = mp(-1, -1);
				}
			}
			else {

				for (int e = 0; e < LG; ++e) {
					what_state[i][j][e] = mp(-1, -1);
					edges[i][j][e] = mp(-1, -1);
				}

				cnt[i][j] = 0;

				for (auto p : trans[i][j]) {
					cnt[i][j] += cnt[p.to][p.coins];
				}

				ll mx = -1;
				int index = -1;

				int u = 0;

				for (auto p : trans[i][j]) {
					if (cnt[p.to][p.coins] > mx) {
						mx = cnt[p.to][p.coins];
						index = u;
					}
					u++;
				}

				ll lsum = 0, rsum = 0;
				for (int e = 0; e < index; ++e) {
					int A = trans[i][j][e].to, B = trans[i][j][e].coins;
					lsum += cnt[A][B];
				}

				for (int e = index + 1; e < trans[i][j].size(); ++e) {
					int A = trans[i][j][e].to, B = trans[i][j][e].coins;
					rsum += cnt[A][B];
				}

				what_state[i][j][0] = mp(trans[i][j][index].to, trans[i][j][index].coins);
				edges[i][j][0] = mp(lsum, rsum);

				for (int e = 1; e < LG; ++e) {
					int A = what_state[i][j][e-1].x, B = what_state[i][j][e-1].y;
					if (what_state[A][B][e-1] == mp((ll) -1, (ll) -1)) break;

					what_state[i][j][e] = what_state[A][B][e-1];
					edges[i][j][e] = mp(edges[i][j][e-1].x + edges[A][B][e-1].x, edges[i][j][e-1].y + edges[A][B][e-1].y);
				}


			}

		}
	}

	for (int i = 0; i < q; ++i) {
		int number;
		ll need;

		cin >> number >> need;
		need--;
		number--;

		if (need >= cnt[0][c]) {
			cout << "-1\n";
			continue;
		}

		int pos = 0, rem = c;

		bool decided = false;

		while (!decided) {

			//cout << pos << " " << rem << endl;

			ll L = need, R = cnt[pos][rem] - need - 1;
			ll ltaken = 0, rtaken = 0;

			for (int i = LG-1; i >= 0; --i) {
				if (what_state[pos][rem][i] == mp((ll) -1, (ll) -1)) continue;
				int A = what_state[pos][rem][i].x, B = what_state[pos][rem][i].y;

				//cout << i << " " << pos << " " << rem << " " << A << " " << B << endl;

				if (A > number) continue;
				ll C = edges[pos][rem][i].x, D = edges[pos][rem][i].y;

				if (ltaken + C > L || rtaken + D > R) continue;
				pos = A, rem = B, ltaken += C, rtaken += D;
			}

			need -= ltaken;

			//cout << pos << " " << rem << " " << need << endl;

			for (int u = 0; u < trans[pos][rem].size(); u++) {
				int A = trans[pos][rem][u].to, B = trans[pos][rem][u].coins;
				//cout << " === " << cnt[A][B] << " " << A << " " << B << " " << number << endl;
				if (cnt[A][B] <= need) {
					need -= cnt[A][B];
					continue;
				}
				else {
					if (A > number) {
						vector<int> Q;
						for (int f = pos; f < A; ++f) Q.pb(v[f]);
						reverse(all(Q));

						int steps = number - pos;
						cout << Q[steps] + 1 << '\n';
						decided = true;
					}
					else {
						pos = A, rem = B;
					}
					break;
				}
			}


		}

	}




}

int main(){
#ifdef LOCAL
	freopen("E_input.txt", "r", stdin);
	//freopen("E_output.txt", "w", stdout);
#endif
	ios_base::sync_with_stdio(0);
	cin.tie(0);

	int t;
	cin >> t;

	for (int i = 0; i < t; ++i) solve();

}
