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 + 5;
char buf[1 << 12], *pp1 = buf, *pp2 = buf, nc;
int ny;
inline char gc() {
  return pp1 == pp2 &&
                 (pp2 = (pp1 = buf) + fread(buf, 1, 1 << 12, stdin), pp1 == pp2)
             ? EOF
             : *pp1++;
}
inline long long read() {
  long long x = 0;
  for (ny = 1; nc = gc(), (nc < 48 || nc > 57) && nc != EOF;)
    if (nc == 45) ny = -1;
  if (nc < 0) return nc;
  for (x = nc - 48; nc = gc(), 47 < nc && nc < 58 && nc != EOF;
       x = (x << 3) + (x << 1) + (nc ^ 48))
    ;
  return x * ny;
}
int n, c, q, p[MAXN];
struct Node {
  int l, r;
  Node(int l = 0, int r = 0) : l(l), r(r) {}
};
Node L[5][MAXN * 10];
long long w[5][MAXN * 10];
int st[5][MAXN], ed[5][MAXN];
inline long long C(int n, int m) {
  long long ans = 1;
  for (int i = (n - m + 1); i <= (n); i++) ans *= i;
  for (int i = (1); i <= (m); i++) ans /= i;
  return ans;
}
inline long long calc(int n, int c) {
  long long ans = 0;
  for (int i = (0); i <= (c); i++) ans += C(n - 1, i);
  return ans;
}
inline void Init() {
  for (int i = (1); i <= (c); i++) {
    int l = n * 5 + 1, r = n * 5 + 1;
    L[i][l] = Node(1, 1);
    for (int j = (n); j >= (1); j--) {
      static int s[MAXN];
      for (int k = (1); k <= (min(i, n - j)); k++) s[k] = j + k;
      sort(s + 1, s + min(i, n - j) + 1,
           [](int x, int y) { return p[x] < p[y]; });
      for (int k = (1); k <= (min(i, n - j)); k++)
        if (p[s[k]] > p[j]) L[i][++r] = Node(j, s[k]);
      for (int k = (min(i, n - j)); k >= (1); k--)
        if (p[s[k]] < p[j]) L[i][--l] = Node(j, s[k]);
      st[i][j] = l, ed[i][j] = r;
    }
    w[i][l - 1] = 0;
    for (int j = (l); j <= (r); j++)
      w[i][j] =
          w[i][j - 1] + (L[i][j].r != L[i][j].l
                             ? calc(n - L[i][j].r, i - (L[i][j].r - L[i][j].l))
                             : 1);
  }
}
inline int F(int i, int c, long long k) {
  return lower_bound(w[c] + st[c][i], w[c] + ed[c][i] + 1,
                     k + w[c][st[c][i] - 1]) -
         w[c];
}
inline int Solve(int i, long long j) {
  if (j > calc(n, c))
    return -1;
  else {
    static Node pp[MAXN];
    int now = 1, cnt = 0, tt = c;
    for (; tt > 0 && j > 0;) {
      int t = F(now, tt, j);
      if (L[tt][t].l == L[tt][t].r) break;
      pp[++cnt] = L[tt][t];
      j -= w[tt][L[tt][t - 1].r] - w[tt][st[tt][now] - 1],
          now = L[tt][t].r + 1, tt -= L[tt][t].r - L[tt][t].l;
    }
    assert(j >= 0);
    for (int k = (1); k <= (cnt); k++)
      if (pp[k].r >= i && pp[k].l <= i) return p[pp[k].l + pp[k].r - i];
    return p[i];
  }
}
int main() {
  for (int t = read(); t--;) {
    n = read(), c = read(), q = read();
    for (int i = (1); i <= (n); i++) p[i] = read();
    Init();
    for (long long i, j; q--;)
      i = read(), j = read(), cout << Solve(i, j) << '\n';
    memset(w, 0, sizeof(w)), memset(st, 0, sizeof(st)),
        memset(ed, 0, sizeof(ed));
  }
  return 0;
}
