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 maxn = 3e4, maxm = 4 * maxn;
int T, n, c, q, a[maxn + 5], delta[5][maxn + 5];
bool comp(const pair<pair<int, int>, long long> &a,
          const pair<pair<int, int>, long long> &b) {
  return a.second < b.second;
}
template <class type>
struct my_deque {
  type q[2 * maxm + 10], *l, *r = l = q + maxm + 5;
  void init() { l = r = q + maxm + 5; }
  void push_back(type x) { *r++ = x; }
  void push_front(type x) { *--l = x; }
};
my_deque<pair<pair<int, int>, long long> > D[5];
long long ways(int n, int c) {
  if (n == 0) {
    return 1;
  }
  long long cur = 1, sum = 1;
  for (int i = (1); i <= int(c); i++) {
    cur *= (n - i);
    cur /= i;
    sum += cur;
  }
  return sum;
}
void prepare(my_deque<pair<pair<int, int>, long long> > &D) {
  for (pair<pair<int, int>, long long> *x = D.l + 1; x < D.r; x++) {
    x->second += (x - 1)->second;
  }
}
pair<pair<int, int>, long long> query(int x, int c, long long k) {
  k += delta[c][x];
  pair<pair<int, int>, long long> *p = lower_bound(
      D[c].l, D[c].r, pair<pair<int, int>, long long>(pair<int, int>(0, 0), k),
      comp);
  return pair<pair<int, int>, long long>(p->first,
                                         p == D[c].l ? 0ll : (p - 1)->second);
}
int main() {
  scanf("%d", &T);
  while (T-- > 0) {
    scanf("%d %d %d", &n, &c, &q);
    for (int i = (1); i <= int(n); i++) {
      scanf("%d", &a[i]);
    }
    for (int i = (0); i <= int(c); i++) {
      D[i].init();
      D[i].push_back(
          pair<pair<int, int>, long long>(pair<int, int>(0, 0), 1ll));
    }
    for (int k = (1); k <= int(c); k++) {
      memset(delta[k] + 1, 0, n << 2);
      for (int i = (n - 1); i >= int(1); i--) {
        for (int j = (1); j <= int(min(n - i, k)); j++) {
          pair<pair<int, int>, long long> x = pair<pair<int, int>, long long>(
              pair<int, int>(i, j), ways(n - i - j, k - j));
          if (a[i + k] > a[i]) {
            D[k].push_back(x);
          } else {
            D[k].push_front(x);
            delta[k][i + 1] += x.second;
          }
        }
      }
      for (int i = (2); i <= int(n); i++) {
        delta[k][i] += delta[k][i - 1];
      }
    }
    for (int k = (0); k <= int(c); k++) {
      prepare(D[k]);
    }
    long long lim = ways(n, c);
    for (int i; q-- > 0;) {
      long long j;
      scanf("%d %lld", &i, &j);
      if (j > lim) {
        puts("-1");
        continue;
      }
      int s = 1, l = c;
      while (s <= n) {
        pair<pair<int, int>, long long> x = query(s, l, j);
        pair<int, int> p = x.first;
        if (p == pair<int, int>(0, 0) || i < p.first) {
          printf("%d ", a[i]);
          goto next_query;
        }
        if (i <= p.first + p.second) {
          printf("%d ", a[2 * p.first + p.second - i]);
          goto next_query;
        }
        s = p.first + p.second + 1;
        j -= x.second;
        l -= p.second;
      }
    next_query:
      void();
    }
  }
  return 0;
}
