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;
long long dp[maxn][5];
int p[maxn];
int n, c, q;
int idx;
int cmp(int x, int y) { return p[idx + x] < p[idx + y]; }
vector<int> s[maxn];
long long L[maxn][5], R[maxn][5];
long long SL[maxn][5];
void init() {
  scanf("%d%d%d", &n, &c, &q);
  for (int i = (1); i < (n + 1); ++i) scanf("%d", &p[i]);
  p[0] = -1;
  for (int i = (0); i < (c + 1); ++i) dp[n + 1][i] = 1;
  for (int i = n; i > 0; --i) {
    s[i].clear();
    for (int j = 0; j <= c; ++j) {
      if (i + j <= n) s[i].push_back(j);
      dp[i][j] = 0;
      for (int k = 0; k <= j && i + k <= n; ++k)
        dp[i][j] += dp[i + k + 1][j - k];
    }
    idx = i;
    sort(s[i].begin(), s[i].end(), cmp);
  }
  for (int i = 1; i <= n; ++i) {
    for (int j = 0; j <= c; ++j) {
      long long sum = 0;
      for (int x : s[i]) {
        if (x > j) continue;
        if (x == 0) break;
        sum += dp[i + x + 1][j - x];
      }
      L[i][j] = sum;
      R[i][j] = sum + dp[i + 1][j];
    }
  }
  for (int i = (1); i < (n + 1); ++i)
    for (int j = (0); j < (c + 1); ++j) SL[i][j] = SL[i - 1][j] + L[i][j];
}
int work(int pos, long long rk) {
  if (rk > dp[1][c]) return 0;
  int cur = c;
  for (int i = 1; i <= n; ++i) {
    if (i > pos) return pos;
    if (rk > L[i][cur] && rk <= R[i][cur]) {
      int l = i, r = n;
      int res = -1;
      long long del = SL[i - 1][cur];
      while (l <= r) {
        if (SL[((l + r) >> 1)][cur] - del >= rk) {
          r = ((l + r) >> 1) - 1;
        } else {
          res = ((l + r) >> 1);
          l = ((l + r) >> 1) + 1;
        }
      }
      assert(res != -1);
      rk -= SL[res][cur] - del;
      i = res;
    } else if (rk <= L[i][cur]) {
      for (int x : s[i]) {
        if (x > cur) continue;
        if (rk > dp[i + x + 1][cur - x])
          rk -= dp[i + x + 1][cur - x];
        else {
          cur -= x;
          if (pos <= i + x && pos >= i) {
            pos = i + x + i - pos;
          }
          i += x;
          break;
        }
      }
    } else {
      rk -= R[i][cur];
      int f = 0;
      for (int x : s[i]) {
        if (x > cur) continue;
        if (x == 0) {
          f = 1;
          continue;
        }
        if (f == 0) continue;
        if (rk > dp[i + x + 1][cur - x])
          rk -= dp[i + x + 1][cur - x];
        else {
          cur -= x;
          if (pos <= i + x && pos >= i) pos = i + x + i - pos;
          i += x;
          break;
        }
      }
    }
  }
  return pos;
}
void sol() {
  while (q--) {
    int pos;
    long long rk;
    scanf("%d%lld", &pos, &rk);
    int cur = c;
    printf("%d\n", p[work(pos, rk)]);
  }
}
int main() {
  int T;
  cin >> T;
  while (T--) {
    init();
    sol();
  }
  return 0;
}
