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 namespace std;
const int N = 3e4 + 9;
const long long mod = 998244353;
const long long Inf = 1e18;
long long dp[N][5];
int p[N];
vector<int> s[N];
long long L[N][5][16], R[N][5][16];
int main() {
  int T;
  scanf("%d", &T);
  while (T--) {
    int n, c, q;
    scanf("%d%d%d", &n, &c, &q);
    for (int i = (0); i < (n); ++i) scanf("%d", &p[i]);
    for (int i = (0); i < (c + 1); ++i) dp[n][i] = 1;
    for (int i = (n)-1; i >= (0); --i) {
      for (int j = (0); j < (c + 1); ++j) {
        dp[i][j] = 0;
        for (int k = (0); k < (j + 1); ++k) {
          if (i + k < n) dp[i][j] += dp[i + k + 1][j - k];
        }
      }
    }
    for (int i = (0); i < (n); ++i) {
      s[i].clear();
      for (int j = (0); j < (c + 1); ++j) {
        if (i + j < n) s[i].push_back(j);
      }
      sort(s[i].begin(), s[i].end(),
           [&](int a, int b) { return p[i + a] < p[i + b]; });
    }
    int lim = 0;
    while ((1 << lim) < n) ++lim;
    for (int i = (0); i < (n); ++i)
      for (int j = (0); j < (c + 1); ++j)
        for (int k = (0); k < (lim + 1); ++k) L[i][j][k] = R[i][j][k] = 0;
    for (int i = (n)-1; i >= (0); --i) {
      for (int j = (0); j < (c + 1); ++j) {
        if (i + j >= n) break;
        long long sum = 0;
        for (auto v : s[i]) {
          if (v > j) continue;
          if (v == 0) break;
          sum += dp[i + v + 1][j - v];
        }
        L[i][j][0] = sum;
        R[i][j][0] = sum + dp[i + 1][j];
        for (int k = (1); k < (lim + 1); ++k) {
          if (i + (1 << k) <= n) {
            L[i][j][k] = L[i][j][k - 1] + L[i + (1 << k - 1)][j][k - 1];
            R[i][j][k] = L[i][j][k - 1] + R[i + (1 << k - 1)][j][k - 1];
          }
        }
      }
    }
    while (q--) {
      int pos;
      long long id;
      scanf("%d%lld", &pos, &id);
      if (id > dp[0][c]) {
        puts("-1");
        continue;
      }
      --pos;
      --id;
      int i = 0, ans = p[pos], r = c;
      int cnt = 0;
      while (i < n) {
        ++cnt;
        if (cnt > 6) return 0;
        for (int j = lim; j >= 0; --j) {
          if (i + (1 << j) <= n && L[i][r][j] <= id && id < R[i][r][j]) {
            i += 1 << j;
            id -= L[i][r][j];
          }
        }
        if (i == n) break;
        for (auto v : s[i]) {
          if (v > r) continue;
          if (id >= dp[i + v + 1][r - v]) {
            id -= dp[i + v + 1][r - v];
          } else {
            int i1 = i + v;
            r -= v;
            if (i <= pos && pos <= i1) {
              ans = p[i + i1 - pos];
            }
            i = i1 + 1;
            break;
          }
        }
      }
      printf("%d\n", ans);
    }
  }
}
