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 MX = 30300;
const long long inf = 2000000000000000000LL;
int t, n, m, q, i, j, k, le, ri, h, r, pos, nls, ngr, ans[7], p[MX];
long long cur, now, sta, f[MX][7], fls[MX * 5][7], fgr[MX * 5][7];
pair<int, int> ls[MX * 5], gr[MX * 5];
bool cmpls(const pair<int, int>& x, const pair<int, int>& y) {
  if (x.first != y.first) return x.first < y.first;
  return p[x.second] < p[y.second];
}
bool cmpgr(const pair<int, int>& x, const pair<int, int>& y) {
  if (x.first != y.first) return x.first > y.first;
  return p[x.second] < p[y.second];
}
int main() {
  for (j = 0; j < 5; j++) f[0][j] = int(j == 0);
  for (i = 1; i < MX; i++)
    for (j = 0; j < 5; j++) {
      cur = f[i - 1][j];
      if (j > 0) {
        cur += f[i - 1][j - 1];
        if (cur > inf) cur = inf;
      }
      f[i][j] = cur;
    }
  for (i = 0; i < MX; i++)
    for (j = 1; j < 5; j++) {
      f[i][j] += f[i][j - 1];
      if (f[i][j] > inf) f[i][j] = inf;
    }
  scanf("%d", &t);
  while (t--) {
    scanf("%d%d%d", &n, &m, &q);
    nls = ngr = 0;
    for (i = 1; i <= n; i++) {
      scanf("%d", &p[i]);
      for (j = 1; j < i && j <= m; j++)
        if (p[i] < p[i - j])
          ls[++nls] = {i - j, i};
        else
          gr[++ngr] = {i - j, i};
    }
    sort(ls + 1, ls + nls + 1, cmpls);
    sort(gr + 1, gr + ngr + 1, cmpgr);
    for (j = 0; j <= m; j++) fls[0][j] = fgr[0][j] = 0;
    for (i = 1; i <= nls; i++)
      for (j = 0; j <= m; j++) {
        fls[i][j] = fls[i - 1][j];
        k = ls[i].second - ls[i].first;
        if (k <= j) {
          fls[i][j] += f[max(0, n - ls[i].second - 1)][j - k];
          if (fls[i][j] > inf) fls[i][j] = inf;
        }
      }
    for (i = 1; i <= ngr; i++)
      for (j = 0; j <= m; j++) {
        fgr[i][j] = fgr[i - 1][j];
        k = gr[i].second - gr[i].first;
        if (k <= j) {
          fgr[i][j] += f[max(0, n - gr[i].second - 1)][j - k];
          if (fgr[i][j] > inf) fgr[i][j] = inf;
        }
      }
    while (q--) {
      scanf("%d%I64d", &k, &cur);
      if (fls[nls][m] + fgr[ngr][m] + 1 < cur) {
        puts("-1");
        continue;
      }
      j = m;
      pos = 1;
      r = 0;
      while (pos < n && j > 0) {
        ls[0] = {0, 0};
        le = 0;
        ri = nls;
        while (le < ri) {
          h = (le + ri) / 2;
          if (ls[h].first < pos)
            le = h + 1;
          else
            ri = h;
        }
        sta = (le > 0) ? fls[le - 1][j] : 0;
        now = fls[nls][j] - sta;
        if (now + 1 == cur) break;
        if (cur <= now) {
          ri = nls;
          while (le < ri) {
            h = (le + ri) / 2;
            if (fls[h][j] - sta < cur)
              le = h + 1;
            else
              ri = h;
          }
          cur -= fls[ri - 1][j] - sta;
          for (int e = ls[ri].first; e < ls[ri].second; e++) ans[r++] = e;
          pos = ls[ri].second + 1;
          j -= ls[ri].second - ls[ri].first;
        } else {
          cur -= now + 1;
          gr[0] = {n, n};
          le = 0;
          ri = ngr;
          while (le < ri) {
            h = (le + ri) / 2 + 1;
            if (gr[h].first < pos)
              ri = h - 1;
            else
              le = h;
          }
          le = 0;
          while (le < ri) {
            h = (le + ri) / 2;
            if (fgr[h][j] < cur)
              le = h + 1;
            else
              ri = h;
          }
          if (ri > 0) cur -= fgr[ri - 1][j];
          for (int e = gr[ri].first; e < gr[ri].second; e++) ans[r++] = e;
          pos = gr[ri].second + 1;
          j -= gr[ri].second - gr[ri].first;
        }
        break;
      }
      for (i = 0; i < r; i = j) {
        for (j = i; j < r && ans[j] == ans[i] + j - i; j++)
          ;
        if (k >= ans[i] && k <= ans[j - 1] + 1) {
          printf("%d\n", p[ans[j - 1] + 1 - (k - ans[i])]);
          break;
        }
      }
      if (i >= r) printf("%d\n", p[k]);
    }
  }
  return 0;
}
