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>
#pragma GCC optimize("Ofast")
using namespace std;
void *wmem;
char memarr[96000000];
template <class S, class T>
inline S min_L(S a, T b) {
  return a <= b ? a : b;
}
template <class T>
inline void walloc1d(T **arr, int x, void **mem = &wmem) {
  static int skip[16] = {0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
  (*mem) = (void *)(((char *)(*mem)) + skip[((unsigned long long)(*mem)) & 15]);
  (*arr) = (T *)(*mem);
  (*mem) = ((*arr) + x);
}
template <class T>
inline void walloc1d(T **arr, int x1, int x2, void **mem = &wmem) {
  walloc1d(arr, x2 - x1, mem);
  (*arr) -= x1;
}
template <class T1>
void sortA_L(int N, T1 a[], void *mem = wmem) {
  sort(a, a + N);
}
template <class T1, class T2>
void sortA_L(int N, T1 a[], T2 b[], void *mem = wmem) {
  int i;
  pair<T1, T2> *arr;
  walloc1d(&arr, N, &mem);
  for (i = (0); i < (N); i++) {
    arr[i].first = a[i];
    arr[i].second = b[i];
  }
  sort(arr, arr + N);
  for (i = (0); i < (N); i++) {
    a[i] = arr[i].first;
    b[i] = arr[i].second;
  }
}
inline int my_getchar() {
  static char buf[1048576];
  static int s = 1048576;
  static int e = 1048576;
  if (s == e && e == 1048576) {
    e = fread(buf, 1, 1048576, stdin);
    s = 0;
  }
  if (s == e) {
    return EOF;
  }
  return buf[s++];
}
inline void rd(int &x) {
  int k;
  int m = 0;
  x = 0;
  for (;;) {
    k = my_getchar();
    if (k == '-') {
      m = 1;
      break;
    }
    if ('0' <= k && k <= '9') {
      x = k - '0';
      break;
    }
  }
  for (;;) {
    k = my_getchar();
    if (k < '0' || k > '9') {
      break;
    }
    x = x * 10 + k - '0';
  }
  if (m) {
    x = -x;
  }
}
inline void rd(long long &x) {
  int k;
  int m = 0;
  x = 0;
  for (;;) {
    k = my_getchar();
    if (k == '-') {
      m = 1;
      break;
    }
    if ('0' <= k && k <= '9') {
      x = k - '0';
      break;
    }
  }
  for (;;) {
    k = my_getchar();
    if (k < '0' || k > '9') {
      break;
    }
    x = x * 10 + k - '0';
  }
  if (m) {
    x = -x;
  }
}
inline int rd_int(void) {
  int x;
  rd(x);
  return x;
}
struct MY_WRITER {
  char buf[1048576];
  int s;
  int e;
  MY_WRITER() {
    s = 0;
    e = 1048576;
  }
  ~MY_WRITER() {
    if (s) {
      fwrite(buf, 1, s, stdout);
    }
  }
};
MY_WRITER MY_WRITER_VAR;
void my_putchar(int a) {
  if (MY_WRITER_VAR.s == MY_WRITER_VAR.e) {
    fwrite(MY_WRITER_VAR.buf, 1, MY_WRITER_VAR.s, stdout);
    MY_WRITER_VAR.s = 0;
  }
  MY_WRITER_VAR.buf[MY_WRITER_VAR.s++] = a;
}
inline void wt_L(char a) { my_putchar(a); }
inline void wt_L(int x) {
  int s = 0;
  int m = 0;
  char f[10];
  if (x < 0) {
    m = 1;
    x = -x;
  }
  while (x) {
    f[s++] = x % 10;
    x /= 10;
  }
  if (!s) {
    f[s++] = 0;
  }
  if (m) {
    my_putchar('-');
  }
  while (s--) {
    my_putchar(f[s] + '0');
  }
}
template <class S>
inline void arrInsert(const int k, int &sz, S a[], const S aval) {
  int i;
  sz++;
  for (i = sz - 1; i > k; i--) {
    a[i] = a[i - 1];
  }
  a[k] = aval;
}
template <class S, class T>
inline void arrInsert(const int k, int &sz, S a[], const S aval, T b[],
                      const T bval) {
  int i;
  sz++;
  for (i = sz - 1; i > k; i--) {
    a[i] = a[i - 1];
  }
  for (i = sz - 1; i > k; i--) {
    b[i] = b[i - 1];
  }
  a[k] = aval;
  b[k] = bval;
}
template <class S, class T, class U>
inline void arrInsert(const int k, int &sz, S a[], const S aval, T b[],
                      const T bval, U c[], const U cval) {
  int i;
  sz++;
  for (i = sz - 1; i > k; i--) {
    a[i] = a[i - 1];
  }
  for (i = sz - 1; i > k; i--) {
    b[i] = b[i - 1];
  }
  for (i = sz - 1; i > k; i--) {
    c[i] = c[i - 1];
  }
  a[k] = aval;
  b[k] = bval;
  c[k] = cval;
}
template <class S, class T, class U, class V>
inline void arrInsert(const int k, int &sz, S a[], const S aval, T b[],
                      const T bval, U c[], const U cval, V d[], const V dval) {
  int i;
  sz++;
  for (i = sz - 1; i > k; i--) {
    a[i] = a[i - 1];
  }
  for (i = sz - 1; i > k; i--) {
    b[i] = b[i - 1];
  }
  for (i = sz - 1; i > k; i--) {
    c[i] = c[i - 1];
  }
  for (i = sz - 1; i > k; i--) {
    d[i] = d[i - 1];
  }
  a[k] = aval;
  b[k] = bval;
  c[k] = cval;
  d[k] = dval;
}
template <class S, class T>
inline S chmin(S &a, T b) {
  if (a > b) {
    a = b;
  }
  return a;
}
template <class S, class T>
inline S chmax(S &a, T b) {
  if (a < b) {
    a = b;
  }
  return a;
}
int N;
int C;
int Q;
int A[30000];
int X;
long long Y;
long long cnt[5][30000 + 2];
int sz;
int lis[5];
int ind[5];
int usz[30000 + 2];
int ulis[30000 + 2][5];
int dsz[30000 + 2];
int dlis[30000 + 2][5];
long long skipL[5][30000 + 2];
long long skipR[5][30000 + 2];
long long skipV[5][30000 + 2];
int skip = 150;
int main() {
  int t_ynMSdg;
  wmem = memarr;
  int i;
  int j;
  int k;
  int c;
  for (i = (0); i < (5); i++) {
    cnt[i][0] = 1;
  }
  for (i = (0); i < (5); i++) {
    for (k = (0); k < (30000); k++) {
      for (j = (0); j < (min_L(k, i) + 1); j++) {
        cnt[i][k + 1] += cnt[i - j][k - j];
        if (cnt[i][k + 1] > 2000000000000000000LL) {
          cnt[i][k + 1] = 2000000000000000000LL;
        }
      }
    }
  }
  int KrdatlYV = rd_int();
  for (t_ynMSdg = (0); t_ynMSdg < (KrdatlYV); t_ynMSdg++) {
    int Hjfu7Vx7;
    rd(N);
    rd(C);
    rd(Q);
    {
      int a2conNHc;
      for (a2conNHc = (0); a2conNHc < (N); a2conNHc++) {
        rd(A[a2conNHc]);
      }
    }
    for (k = (0); k < (N); k++) {
      sz = 0;
      for (i = (0); i < (C + 1); i++) {
        if (k + i < N) {
          arrInsert(sz, sz, ind, i, lis, A[k + i]);
        }
      }
      sortA_L(sz, lis, ind);
      j = usz[k] = dsz[k] = 0;
      for (i = (0); i < (sz); i++) {
        if (ind[i] == 0) {
          j++;
          continue;
        }
        if (j == 0) {
          ulis[k][usz[k]++] = ind[i];
        }
        if (j == 1) {
          dlis[k][dsz[k]++] = ind[i];
        }
      }
    }
    for (k = (0); k < (N); k++) {
      for (c = (0); c < (C + 1); c++) {
        long long sm = 0;
        skipL[c][k] = -4611686016279904256LL;
        skipR[c][k] = 4611686016279904256LL;
        if (k + skip + 5 >= N) {
          swap(skipL[c][k], skipR[c][k]);
          continue;
        }
        for (j = (k); j < (k + skip); j++) {
          for (i = (0); i < (usz[j]); i++) {
            if (c <= ulis[j][i]) {
              sm += cnt[c - ulis[j][i]][N - k - ulis[j][i]];
            }
          }
          chmax(skipL[c][k], sm);
          chmin(skipR[c][k], sm + cnt[c][N - k - 1]);
        }
        skipV[c][k] = sm;
      }
    }
    for (Hjfu7Vx7 = (0); Hjfu7Vx7 < (Q); Hjfu7Vx7++) {
      rd(X);
      X += (-1);
      rd(Y);
      Y += (-1);
      if (Y >= cnt[C][N]) {
        wt_L(-1);
        wt_L('\n');
        continue;
      }
      c = C;
      for (k = (0); k < (N); k++) {
        if (skipL[c][k] < Y && Y < skipR[c][k]) {
          k += skip - 1;
          Y -= skipV[c][k];
          continue;
        }
        for (i = (0); i < (usz[k]); i++) {
          if (c <= ulis[k][i]) {
            if (Y < cnt[c - ulis[k][i]][N - k - ulis[k][i]]) {
              if (X <= k + ulis[k][i]) {
                wt_L(A[k + ulis[k][i] - (X - k)]);
                wt_L('\n');
                goto szDqbNYU;
              }
              c -= ulis[k][i];
              k += ulis[k][i];
              continue;
            } else {
              Y -= cnt[c - ulis[k][i]][N - k - ulis[k][i]];
            }
          }
        }
        if (Y < cnt[c][N - k - 1]) {
          if (X == k) {
            wt_L(A[k]);
            wt_L('\n');
            break;
          }
          continue;
        } else {
          Y -= cnt[c][N - k - 1];
        }
        for (i = (0); i < (dsz[k]); i++) {
          if (c <= dlis[k][i]) {
            if (Y < cnt[c - dlis[k][i]][N - k - dlis[k][i]]) {
              if (X <= k + dlis[k][i]) {
                wt_L(A[k + dlis[k][i] - (X - k)]);
                wt_L('\n');
                goto szDqbNYU;
              }
              c -= dlis[k][i];
              k += dlis[k][i];
              continue;
            } else {
              Y -= cnt[c - dlis[k][i]][N - k - dlis[k][i]];
            }
          }
        }
      }
    szDqbNYU:;
    }
  }
  return 0;
}
