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 N = 30000 + 1;
const int C = 4 + 1;

long long ways[N][C];

long long before[N][C], after[N][C], y;
int perm[N], n, c, q, x;
vector<int> options[N];

void solve(int i, int j) {
  int l = i, r = n;
  while (l < r) {
    int m = (l + r + 1) / 2;
    long long a = after[m][j] - after[i][j];
    long long b = before[m][j] - before[i][j];
    if (b <= y && y + a < ways[n - i][j]) {
      l = m;
    } else {
      r = m - 1;
    }
  }

  if (l == n) {
    cout << perm[x] << "\n";
    return;
  }

  y -= before[l][j] - before[i][j];
  for (auto k : options[l]) {
    int a = l + k + 1;
    if (k <= j) {
      if (ways[n - a][j - k] <= y) {
        y -= ways[n - a][j - k];
      } else {
        reverse(perm + l, perm + a);
        solve(a, j - k);
        reverse(perm + l, perm + a);
        return;
      }
    }
  }
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);

  for (int i = 0; i < N; ++i) {
    for (int j = 0; j < C; ++j) {
      if (i == 0) {
        ways[i][j] = 1;
      } else {
        ways[i][j] = (j == 0) ? 0 : ways[i][j - 1];
        long long choose = 1;
        for (int k = 0; k < j; ++k) {
          choose *= i - 1 - k;
          choose /= k + 1;
        }
        ways[i][j] += choose;
      }
    }
  }

  int t;
  cin >> t;

  while (t--) {
    cin >> n >> c >> q;

    for (int i = 0; i < n; ++i) {
      cin >> perm[i];
    }

    for (int i = 0; i < n; ++i) {
      options[i].clear();
      for (int j = 0; j <= c && i + j < n; ++j) {
        options[i].push_back(j);
      }

      sort(options[i].begin(), options[i].end(), [&](int a, int b) {
        return perm[i + a] < perm[i + b];
      });

      for (int j = 0; j <= c; ++j) {
        before[i + 1][j] = after[i + 1][j] = 0;
        for (auto k : options[i]) {
          int a = i + k + 1;
          if (k <= j) {
            if (perm[i + k] < perm[i]) {
              before[i + 1][j] += ways[n - a][j - k];
            } else if (perm[i + k] > perm[i]) {
              after[i + 1][j] += ways[n - a][j - k];
            }
          }
        }
      }
    }

    for (int i = 0; i < n; ++i) {
      for (int j = 0; j <= c; ++j) {
        before[i + 1][j] += before[i][j];
        after[i + 1][j] += after[i][j];
      }
    }

    while (q--) {
      cin >> x >> y;
      --x, --y;
      if (y >= ways[n][c]) {
        cout << -1 << "\n";
      } else {
        solve(0, c);
      }
    }
  }
}
