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

/**
 *    author:  tourist
 *    created: 05.01.2021 18:25:48       
**/
#include <bits/stdc++.h>

using namespace std;

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int tt;
  cin >> tt;
  while (tt--) {
    int n, c, q;
    cin >> n >> c >> q;
    vector<int> p(n);
    for (int i = 0; i < n; i++) {
      cin >> p[i];
      --p[i];
    }
    vector<vector<long long>> ways(n + 1, vector<long long>(c + 1));
    for (int j = 0; j <= c; j++) {
      ways[n][j] = 1;
    }
    for (int i = n - 1; i >= 0; i--) {
      for (int j = 0; j <= c; j++) {
        ways[i][j] = ways[i + 1][j];
        for (int k = 1; k <= j; k++) {
          if (i + k < n) {
            ways[i][j] += ways[i + k + 1][j - k];
          }
        }
      }
    }
    vector<vector<long long>> sumL(c + 1, vector<long long>(n + 1));
    vector<vector<long long>> sumR(c + 1, vector<long long>(n + 1));
    for (int rm = 0; rm <= c; rm++) {
      for (int i = 0; i < n; i++) {
        sumL[rm][i + 1] = sumL[rm][i];
        sumR[rm][i + 1] = sumR[rm][i];
        for (int k = 1; k <= rm; k++) {
          if (i + k < n) {
            if (p[i] < p[i + k]) {
              sumR[rm][i + 1] += ways[i + k + 1][rm - k];
            } else {
              sumL[rm][i + 1] += ways[i + k + 1][rm - k];
            }
          }
        }
      }
    }
    vector<int> order;
    while (q--) {
      int pos;
      long long id;
      cin >> pos >> id;
      --pos; --id;
      if (id >= ways[0][c]) {
        cout << -1 << '\n';
        continue;
      }
      int ans = -1;
      int i = 0;
      int rm = c;
      while (i < n) {
        assert(id < ways[i][rm]);
        int low = i, high = n;
        while (low < high) {
          int mid = (low + high + 1) >> 1;
          if (sumL[rm][mid] - sumL[rm][i] > id || sumR[rm][mid] - sumR[rm][i] > ways[i][rm] - 1 - id) {
            high = mid - 1;
          } else {
            low = mid;
          }
        }
        if (pos < low) {
          ans = p[pos];
          break;
        }
        id -= sumL[rm][low] - sumL[rm][i];
        assert(id >= 0 && id < ways[low][rm]);
        i = low;
        order.clear();
        for (int k = 0; k <= rm; k++) {
          if (i + k < n) {
            order.push_back(k);
          }
        }
        sort(order.begin(), order.end(), [&](int x, int y) {
          return p[i + x] < p[i + y];
        });
        int shift = -1;
        for (int v : order) {
          long long cur = ways[i + v + 1][rm - v];
          if (id < cur) {
            shift = v;
            break;
          }
          id -= cur;
        }
        assert(shift != -1);
        assert(shift != 0);
        if (pos <= i + shift) {
          ans = p[i + (i + shift) - pos];
          break;
        }
        i += shift + 1;
        rm -= shift;
      }
      assert(ans != -1);
      cout << ans + 1 << '\n';
    }
  }
  return 0;
}
