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 = 3e4;
__int128 dp[N][11][11];
__int128 dpsum[N][11];
vector<pair<int, int> > vec[N][11];
__int128 dppref[N][11];
__int128 dp2[N][11][11];
signed main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  int t;
  cin >> t;
  while (t--) {
    int n, c, q;
    cin >> n >> c >> q;
    vector<int> p(n);
    for (int i = 0; i < n; i++) {
      cin >> p[i];
    }
    for (int i = 0; i < n; i++) {
      for (int j = 0; j <= 10; j++) {
        dppref[i][j] = 0;
        dpsum[i][j] = 0;
        for (int c1 = 0; c1 <= 10; c1++) {
          dp[i][j][c1] = 0;
        }
      }
    }
    for (int i = n - 1; i >= 0; i--) {
      for (int j = 0; j <= c && i + j < n; j++) {
        if (i + j == n - 1) {
          dp[i][j][j] = 1;
        } else {
          for (int k = 0; k + j <= c; k++) {
            dp[i][j + k][j] += dpsum[i + j + 1][k];
          }
        }
      }
      for (int j = 0; j <= c; j++) {
        for (int k = 0; k <= c; k++) {
          dpsum[i][j] += dp[i][j][k];
        }
      }
    }
    for (int i = 0; i < n; i++) {
      for (int j = 0; j <= c; j++) {
        for (int k = 0; k <= c; k++) {
          if (k + i >= n || p[k + i] >= p[i]) {
            continue;
          }
          dppref[i][j] += dp[i][j][k];
        }
        if (j != 0) {
          dppref[i][j] += dppref[i][j - 1];
        }
        if (i != 0) {
          dppref[i][j] += dppref[i - 1][j];
        }
      }
    }
    for (int i = 0; i < n; i++) {
      for (int k = 0; k <= c; k++) {
        for (int j = 0; j <= c; j++) {
          dp2[i][j][k] = dp[i][j][k];
          if (j != 0) {
            dp2[i][j][k] += dp2[i][j - 1][k];
          }
        }
      }
    }
    __int128 dp1[n][11];
    for (int i = 0; i < n; i++) {
      for (int j = 0; j <= c; j++) {
        dp1[i][j] = dp[i][j][0];
        if (j != 0) {
          dp1[i][j] += dp[i][j - 1][0];
        }
      }
    }
    __int128 sumall = 0;
    for (int j = 0; j <= c; j++) {
      sumall += dpsum[0][j];
    }
    assert(sumall >= 0 && sumall <= 1e18);
    for (int i = 0; i < n; i++) {
      for (int j = 0; j <= c; j++) {
        vec[i][j].clear();
        if (j != 0) {
          vec[i][j] = vec[i][j - 1];
        }
        if (j + i < n) {
          vec[i][j].push_back({p[i + j], j});
          sort(vec[i][j].begin(), vec[i][j].end());
        }
      }
    }
    while (q--) {
      long long cnt;
      int ind;
      cin >> ind >> cnt;
      ind--;
      int ans = -1;
      if (sumall >= cnt) {
        int st = 0;
        int call = 0;
        int ost = c;
        while (st != n) {
          if (st != 5) {
          }
          int l = st - 1, r = n - 1;
          while (r - l > 1) {
            int midd = (r + l) / 2;
            __int128 t1 = dppref[midd][ost];
            if (st != 0) {
              t1 -= dppref[st - 1][ost];
            }
            __int128 t2 = t1 + dp1[midd][ost];
            if (st != 5) {
            }
            if (t1 < cnt && t2 >= cnt) {
              l = midd;
            } else {
              r = midd;
            }
          }
          if (l != st - 1) {
            __int128 t1 = dppref[l][ost];
            if (st != 0) {
              t1 -= dppref[st - 1][ost];
            }
            cnt -= t1;
          }
          if (ind >= st && ind < l + 1) {
            ans = p[ind];
          }
          st = l + 1;
          for (int i = 0; i < vec[st][ost].size(); i++) {
            int it = vec[st][ost][i].second;
            __int128 val = dp2[st][ost][it];
            if (val >= cnt) {
              if (ind >= st && ind <= st + it) {
                ans = p[st + it - (ind - st)];
              }
              ost -= it;
              st += it + 1;
              break;
            } else {
              cnt -= val;
            }
          }
          call++;
        }
      }
      cout << ans << "\n";
    }
  }
  return 0;
}
