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

/**
 *  created: 13/01/2021, 20:24:36
**/

#include <bits/stdc++.h>

using namespace std;

const int max_n = 30033;
const int max_c = 5;
const long long inf = 1000111222000111222LL;

int t, n, c, q, a[max_n];
vector<int> order[max_n];
long long dp[max_n][max_c], A[max_c][max_n], B[max_n][max_c];
__int128 sumA[max_c][max_n];

__int128 get_sum(int c, int l, int r) {
    if (l > r) {
        return 0;
    }
    if (!l) {
        return sumA[c][r];
    }
    return sumA[c][r] - sumA[c][l - 1];
}

int get_last(int pos, long long num, int c) {
    assert(dp[pos][c] >= num);
    int l = pos, r = n + 1;
    while (r - l > 1) {
        int mid = (l + r) / 2;
        if (dp[mid][c] + get_sum(c, pos, mid - 1) >= num) {
            l = mid;
        } else {
            r = mid;
        }
    }
    return l;
}

vector<pair<int, int>> solve(long long num, int c) {
    vector<pair<int, int>> res;
    int pos = 0;
    while (pos < n) {
        int last = get_last(pos, num, c);
        __int128 sum_pref = 0;
        if (pos) {
            sum_pref += sumA[c][pos - 1];
        }
        int first = lower_bound(sumA[c], sumA[c] + n, num + sum_pref) - sumA[c];
        //cout << "#" << pos << ": " << first << " " << last << ", c = " << c << ", num = " << num << "   " << A[c][first] << endl;
        first = min(first, last);
        if (first == n) {
            break;
        }
        num -= get_sum(c, pos, first - 1);
        //cout << "new num = " << num << endl;
        int oldc = c;
        for (int len : order[first]) {
            if (len > c) {
                continue;
            }
            if (num > dp[first + len + 1][c - len]) {
                //cout << "dec " << len << " " << dp[first + len + 1][c - len] << endl;
                num -= dp[first + len + 1][c - len];
            } else {
                assert(len);
                res.push_back({first, len});
                pos = first + len + 1;
                c -= len;
                break;
            }
        }
        assert(c != oldc);
    }
    return res;
}

int get_elem(const vector<pair<int, int>> &v, int pos) {
    for (auto p : v) {
        if (p.first <= pos && pos <= p.first + p.second) {
            pos -= p.first;
            pos = p.second - pos;
            pos += p.first;
            return a[pos];
        }
    }
    return a[pos];
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    scanf("%d", &t);
    while (t--) {
        scanf("%d%d%d", &n, &c, &q);
        for (int i = 0; i < n; ++i) {
            scanf("%d", &a[i]);
        }
        fill(dp[n], dp[n] + c + 1, 1);
        for (int i = n - 1; i >= 0; --i) {
            for (int j = 0; j <= c; ++j) {
                dp[i][j] = 0;
                for (int len = 0; i + len < n && len <= j; ++len) {
                    dp[i][j] += dp[i + len + 1][j - len];
                    dp[i][j] = min(dp[i][j], inf);
                }
            }
            order[i].clear();
            for (int len = 0; len <= c && i + len < n; ++len) {
                order[i].push_back(len);
            }
            sort(order[i].begin(), order[i].end(), [i](int x, int y) { return a[i + x] < a[i + y]; });
            for (int j = 0; j <= c; ++j) {
                B[j][i] = dp[i][j];
                A[j][i] = 0;
                for (int len : order[i]) {
                    if (len == 0) {
                        break;
                    }
                    if (len <= j) {
                        A[j][i] += dp[i + len + 1][j - len];
                        A[j][i] = min(A[j][i], inf);
                    }
                }
            }
        }
        for (int j = 0; j <= c; ++j) {
            sumA[j][0] = A[j][0];
            for (int i = 1; i < n; ++i) {
                sumA[j][i] = sumA[j][i - 1] + A[j][i];
            }
        }
        while (q--) {
            int pos;
            long long num;
            scanf("%d%lld", &pos, &num);
            --pos;
            if (dp[0][c] < num) {
                puts("-1");
            } else {
                vector<pair<int, int>> res = solve(num, c);
                int ans = get_elem(res, pos);
                printf("%d\n", ans);
            }
        }
    }
    return 0;
}
