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>

using ll = long long;
const int N = 300010;
const int M = 5;

ll dp[N][M];
int p[N];
ll low[N][M], high[N][M];
ll pre_low[N][M], pre_high[N][M];

void solve(){
    int n, c, q;
    scanf("%d%d%d", &n, &c, &q);
    for (int i = 0; i <= n; ++ i){
        memset(dp[i], 0, sizeof(dp[i]));
        memset(low[i], 0, sizeof(low[i]));
        memset(high[i], 0, sizeof(high[i]));
    }
    for (int i = 1; i <= n; ++ i){
        scanf("%d", &p[i]);
    }
    for (int i = 0; i <= c; ++ i){
        dp[0][i] = 1;
    }
    for (int i = 1; i <= n; ++ i){
        for (int j = 0; j <= c; ++ j){
            for (int k = 0; k <= j && k + 1 <= i; ++ k){
                ll value = dp[i - k - 1][j - k];
                dp[i][j] += value;
                if (p[n + 1 - (i - k)] < p[n + 1 - i]){
                    low[i][j] += value;
                }
                else if (p[n + 1 - (i - k)] > p[n + 1 - i]){
                    high[i][j] += value;
                }
            }
        }
    }
    for (int i = 0; i <= c; ++ i){
        for (int j = 1; j <= n; ++ j){
            pre_low[j][i] = pre_low[j - 1][i] + low[j][i];
            pre_high[j][i] = pre_high[j - 1][i] + high[j][i];
        }
    }
    while (q --){
        int pos;
        ll num;
        scanf("%d%lld", &pos, &num);
        if (num > dp[n][c]){
            puts("-1");
            continue;
        }
        int len = n, cur = c;
        while (len >= n + 1 - pos){
            int l = 0, r = len;
            while (l < r){
                int mid = (l + r + 1) / 2;
                ll low_num = pre_low[len][cur] - pre_low[len - mid][cur];
                ll high_num = pre_high[len][cur] - pre_high[len - mid][cur];
                if (num <= low_num || num >= dp[len][cur] - high_num + 1){
                    r = mid - 1;
                }
                else{
                    l = mid;
                }
            }
            int left = n + 1 - len, right = left + l - 1;
            if (left <= pos && pos <= right){
                printf("%d\n", p[pos]);
                break;
            }
            num -= pre_low[len][cur] - pre_low[len - l][cur];
            len -= l;
            if (len == 0){
                break;
            }
            using piii = std::tuple <ll, ll, ll>;
            piii pp[M] = {};
            int cnt = 0;
            for (int i = 0; i <= cur && i + 1 <= len; ++ i){
                ll value = dp[len - i - 1][cur - i];
                pp[cnt ++] = {p[n + 1 - (len - i)], i, value};
            }
            std::sort(pp, pp + cnt);
            for (int i = 0; i < cnt; ++ i){
                auto [u, v, w] = pp[i];
                if (num <= w){
                    left = n + 1 - len, right = left + v;
                    if (left <= pos && pos <= right){
                        printf("%d\n", p[right - (pos - left)]);
                    }
                    len -= v + 1;
                    cur -= v;
                    break;
                }
                else{
                    num -= w;
                }
            }
        }
    }
}

int main(){
    int test;
    scanf("%d", &test);
    while (test --){
        solve();
    }
    return 0;
}