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;
long long binom(int n, int k) {
  long long result = 1;
  for (int i = 0; i < k; ++i) {
    result *= n - i;
  }
  for (int i = 1; i <= k; ++i) {
    result /= i;
  }
  return result;
}
long long total_count(int n, int c) {
  c = min(c, n);
  int result = 0;
  for (int i = 0; i <= c; ++i) {
    result += binom(n - 1, i);
  }
  return result;
}
struct Finder {
  int n, c;
  vector<int>& ps;
  vector<vector<int>> adj_list;
  vector<pair<long long, long long>> intervals;
  set<tuple<long long, long long, int>> leaf_intervals;
  Finder(vector<int>& ps, int n, int c)
      : ps(ps),
        n(n),
        c(c),
        adj_list((c + 1) * n),
        intervals((c + 1) * n, {-1, -1}) {
    for (int i = 0; i < n; ++i) {
      int u = (c + 1) * i;
      if (i == n - 1) {
        break;
      }
      vector<int> children(min(n - i, c + 1));
      iota(children.begin(), children.end(), 0);
      sort(children.begin(), children.end(),
           [&](int a, int b) { return ps[i + a] < ps[i + b]; });
      for (int j : children) {
        if (j == 0) {
          adj_list[u].push_back((c + 1) * (i + 1));
        } else {
          adj_list[u].push_back((c + 1) * i + j);
        }
      }
    }
    assign_intervals(0, 0);
    for (int u = 0; u < (c + 1) * n; ++u) {
      auto& interval = intervals[u];
      if (interval.first == -1) {
        continue;
      }
      if (adj_list[u].size() == 0) {
        leaf_intervals.insert({interval.first, interval.second, u});
      }
    }
  }
  int assign_intervals(int u, long long current) {
    long long size = 0;
    int i = u / (c + 1), j = u % (c + 1);
    if (j != 0) {
      size = total_count(n - i - j - 1, c - j);
    } else if (i == n - 1) {
      size = 1;
    } else {
      for (int v : adj_list[u]) {
        size += assign_intervals(v, current + size);
      }
    }
    intervals[u] = {current, current + size};
    return size;
  }
  tuple<long long, int, int> _first_reverse(long long j) {
    long long total_size = get<1>(*leaf_intervals.rbegin());
    assert(j < total_size);
    auto it = leaf_intervals.upper_bound({j, total_size + 1, 0});
    assert(it != leaf_intervals.begin());
    --it;
    int u = get<2>(*it);
    long long remaining = j - get<0>(*it);
    int i = u / (c + 1), k = u % (c + 1);
    return {remaining, i, i + k};
  }
  tuple<long long, int, int> first_reverse(long long j, int pos) {
    long long from, to;
    tie(from, to) = intervals[pos * (c + 1)];
    if (j >= to - from) {
      return {-1, -1, -1};
    }
    return _first_reverse(j + from);
  }
};
void solve() {
  int n, c, q;
  cin >> n >> c >> q;
  vector<int> ps(n);
  for (auto& p : ps) {
    cin >> p;
  }
  vector<pair<int, long long>> queries(q);
  for (auto& query : queries) {
    int i;
    long long j;
    cin >> i >> j;
    --i;
    --j;
    query = {i, j};
  }
  vector<Finder> finders;
  for (int i = 0; i <= c; ++i) {
    finders.push_back(Finder(ps, n, i));
  }
  for (auto& query : queries) {
    int i;
    long long j;
    tie(i, j) = query;
    int c0 = c;
    int pos = 0;
    int result = ps[i];
    while (c0 > 0 && pos < n - 1) {
      long long remaining;
      int from, to;
      tie(remaining, from, to) = finders[c0].first_reverse(j, pos);
      if (remaining == -1) {
        result = -1;
        break;
      }
      if (from <= i && i <= to) {
        result = ps[from + to - i];
        break;
      }
      pos = to + 1;
      j = remaining;
      c0 -= to - from;
    }
    cout << result << "\n";
  }
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int num_test_cases;
  cin >> num_test_cases;
  for (int test_case_num = 1; test_case_num <= num_test_cases;
       ++test_case_num) {
    solve();
  }
  return 0;
}
