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

// In the name of Allah.
// We're nothing and you're everything.
// Ya Ali!

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;

const int maxn = 3e4 + 14, maxc = 5, maxq = 3e5 + 14;
ll options[maxn][maxc];
struct Query {
    int i;
    ll j;
    vector<pair<int, int>> segs;
} queries[maxq];

int main() {
    ios::sync_with_stdio(0), cin.tie(0);
    fill(options[0], options[1], 1);
    for (int i = 1; i < maxn; ++i)
        for (int j = 0; j < maxc; j++)
            for (int k = 0; k <= j and k < i; k++)
                options[i][j] += options[i - k - 1][j - k];
    int t;
    cin >> t;
    while (t--) {
        int n, c, q;
        cin >> n >> c >> q;
        int p[n];
        for (int i = 0; i < n; ++i)
            cin >> p[i];
        vector<int> assigned[c + 1][n + 1];
        for (int i = 0; i < q; ++i) {
            cin >> queries[i].i >> queries[i].j;
            queries[i].i--;
            queries[i].j--;
            assigned[c][0].push_back(i);
            queries[i].segs.clear();
        }
        for (; c; c--) {
            set<int, function<bool(int, int)>> cur_queries(
                    [](int i, int j) { return pair(queries[i].j, i) < pair(queries[j].j, j); });
            ll lazy = 0;
            for (int i = 0; i < n; ++i) {
                for (auto query : assigned[c][i]) {
                    queries[query].j -= lazy;
                    cur_queries.insert(query);
                }
                int opts = min(c + 1, n - i);
                int child[opts];
                iota(child, child + opts, 0);
                sort(child, child + opts, [&i, &p](int j, int k) { return p[i + j] < p[i + k]; });
                int sum_options = options[n - i][c];
                int ch0 = find(child, child + opts, 0) - child;
                for (int j = opts - 1; j > ch0; j--) {
                    int ch = child[j];
                    sum_options -= options[n - i - ch - 1][c - ch];
                    while (!cur_queries.empty() and queries[*cur_queries.rbegin()].j + lazy >= sum_options) {
                        int qi = *cur_queries.rbegin();
                        assigned[c - ch][i + ch + 1].push_back(qi);
                        queries[qi].segs.emplace_back(i, ch);
                        queries[qi].j += lazy - sum_options;
                        cur_queries.erase(--cur_queries.end());
                    }
                }
                for (int j = 0; j < ch0; j++) {
                    int ch = child[j];
                    while (!cur_queries.empty() and
                           queries[*cur_queries.begin()].j + lazy < options[n - i - ch - 1][c - ch]) {
                        int qi = *cur_queries.begin();
                        assigned[c - ch][i + ch + 1].push_back(qi);
                        queries[qi].segs.emplace_back(i, ch);
                        queries[qi].j += lazy;
                        cur_queries.erase(cur_queries.begin());
                    }
                    lazy -= options[n - i - ch - 1][c - ch];
                }
            }
            for(auto qi : cur_queries)
                queries[qi].j += lazy;
        }
        for_each(queries, queries + q, [&p](Query &q) {
            if (q.j > 0)
                cout << "-1\n";
            else {
                int it = lower_bound(q.segs.begin(), q.segs.end(), pair(q.i + 1, -1)) - q.segs.begin();
                if (it-- == 0 or q.i - q.segs[it].first > q.segs[it].second)
                    cout << p[q.i] << '\n';
                else
                    cout << p[q.segs[it].second - (q.i - q.segs[it].first) + q.segs[it].first] << '\n';
            }
        });
    }
}