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

#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
 
#include <bits/stdc++.h>
 
using namespace std;
 
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
 
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;
 
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
 
#define FOR(i, a, b) for (int i=a; i<(b); i++)
#define F0R(i, a) for (int i=0; i<(a); i++)
#define FORd(i,a,b) for (int i = (b)-1; i >= a; i--)
#define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)
#define trav(a,x) for (auto& a : x)
#define uid(a, b) uniform_int_distribution<int>(a, b)(rng)
 
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define ins insert
 
template<class T> bool ckmin(T& a, const T& b) { return b < a ? a = b, 1 : 0; }
template<class T> bool ckmax(T& a, const T& b) { return a < b ? a = b, 1 : 0; }
 
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
 
const int MOD = 1000000007;
const char nl = '\n';
const int MX = 30001; //check the limits, dummy
 
ll ch[MX][5];
 
void solve() {
 
    int N, C, Q; cin >> N >> C >> Q;
    set<pl> cur[C+1];
    ll del[C+1]; F0R(i, C+1) del[i] = 0;
    int rem[Q]; F0R(i, Q) rem[i] = C;
    vector<vi> atPos(N); 
    vpl toAdd[N][C+1]; 
    int pos[Q];
    ll nc[Q]; 
    int ans[Q]; F0R(i, Q) ans[i] = -1;
    int P[N]; F0R(i, N) cin >> P[i];
    F0R(i, Q) {
        int X; ll K; cin >> X >> K; 
        X--; K--;
        cur[C].ins({K, i});
        pos[i] = X;
        nc[i] = K;
        atPos[X].pb(i);
    }
 
    F0R(i, N) {
        F0R(j, C+1) {
            trav(a, toAdd[i][j]) { cur[j].ins({a.f+del[j], a.s});
                //cout << i << " " << j << " " << a.f << " " << a.s << " " << del[j] << " " << nc[a.s] << nl;
                nc[a.s] += del[j];
            }
        }
        F0R(j, C+1) {
            vpi ops;
            F0R(k, j+1) {
                if (i+k < N) {
                    ops.pb({P[i+k], k});
                }
            }
            sort(all(ops));
            ll curSum = 0;
            F0R(x, sz(ops)) {
                pi a = ops[x];
                if (a.s == 0) {
                    ll num = 1; if (i < N-1) num = ch[N-i-2][j];
                    del[j] += curSum;
                    curSum = num;
                } else {
                    ll numWith = 1;
                    if (N-i-a.s-1 > 0) numWith = ch[N-i-a.s-2][j-a.s];
/*                    if (i == 1 && j == 1) {
                        cout << del[j] << " " << curSum << " " << numWith << nl;
                    }*/
                    auto it = cur[j].ub({del[j] + curSum, -1});
                    while (it != cur[j].end() && it->f < del[j] + curSum + numWith) {
                        //process this
                        //cout << "PROC " << i << " " << j << " " << a.s << " " << del[j] << " " << curSum << nl;
                        rem[it->s] -= a.s;
                        if (pos[it->s] <= i+a.s) {
                            if (pos[it->s] >= i) ans[it->s] = P[2*i+a.s-pos[it->s]];
                        } else {
                            toAdd[i+a.s+1][rem[it->s]].pb({it->f-curSum-del[j], it->s});
                            nc[it->s] -= curSum + del[j];
                        }
                        cur[j].erase(it);
                        it = cur[j].ub({del[j] + curSum, -1});
                    }
 
                    curSum += numWith;
                }
/*                if (i == 2 && j == 3) {
                    cout << a.s << " " << del[j] << " " << curSum << nl;
                }*/
            }
            trav(a, atPos[i]) {
                ll num = 1; if (i < N-1) num = ch[N-2-i][j];
/*                if (i == 2 && j == 3 && a == 0) {
                    cout << nc[a] << " " << cur[j].count({nc[a], a}) << " " << num << " " << del[j] << endl;
                }*/
                if (cur[j].count({nc[a], a}) && num > nc[a]-del[j]) {
                    ans[a] = P[i];
                }
            }
 
 
        }
        //deal w/ things to be removed here [uhh what does this mean lol]
    }
 
    F0R(i, Q) {
        cout << ans[i] << nl;
    }
}
 
int main() {
	ios_base::sync_with_stdio(0); cin.tie(0);    
    ch[0][0] = 1;
    FOR(i, 1, 5) ch[0][i] = 0;
    FOR(i, 1, MX) {
        ch[i][0] = 1;
        FOR(j, 1, 5) {
            ch[i][j] = ch[i-1][j-1] + ch[i-1][j];
        }
    }
    F0R(i, MX) {
        FOR(j, 1, 5) {
            ch[i][j] += ch[i][j-1];
        }
    }
    int T = 1;
    cin >> T;
    while(T--) {
        solve();
    }
 
	return 0;
}