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;
void initial(int arr[], int n, int c, int &count) {
  if (n > c)
    count = (n - c) * c + (c - 1) * (c) / 2;
  else
    count = (n - 1) * (n) / 2;
}
int resolveQuery(int arr[], int dp[], int n, int c, int x, long long int y,
                 int count) {
  if (y > count) return -1;
  if (y == 1) return arr[x - 1];
  int start = 1, end = n - 1;
  int mid = (start + end) / 2;
  while (true) {
    mid = (start + end) / 2;
    if (!dp[mid]) {
      initial(arr, mid + 1, c, dp[mid]);
      dp[mid] = count - dp[mid] + 2;
    }
    if (start == end) break;
    if (dp[mid] > y) {
      start = mid + 1;
    } else if (dp[mid] < y) {
      if (mid + 1 >= c) {
        if ((dp[mid] + c - 1) >= y)
          break;
        else
          end = mid - 1;
      } else {
        if ((dp[mid] + mid) >= y)
          break;
        else
          end = mid - 1;
      }
    } else
      break;
  }
  if (dp[mid] == y) {
    if (x - 1 != mid) {
      if (x - 1 != mid - 1)
        return arr[x - 1];
      else
        return arr[mid];
    } else
      return arr[mid - 1];
  } else {
    int coeff = (y - dp[mid] + 1);
    if (x - 1 != mid) {
      if (x - 1 != mid - coeff)
        return arr[x - 1];
      else
        return arr[mid];
    } else
      return arr[mid - coeff];
  }
}
int main() {
  int t;
  cin >> t;
  int n, c, q;
  int x;
  long long int y;
  while (t--) {
    cin >> n >> c >> q;
    int arr[n];
    for (int i = 0; i < n; i++) cin >> arr[i];
    int count;
    initial(arr, n, c, count);
    count++;
    int dp[n];
    memset(dp, 0, sizeof(dp));
    dp[n - 1] = 2;
    dp[0] = count;
    dp[1] = count;
    while (q--) {
      cin >> x >> y;
      cout << resolveQuery(arr, dp, n, c, x, y, count) << endl;
    }
  }
}
