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

// Main correct solution + fast input (IgorI)

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

template <class T = int> inline T readInt();
template <class T = int64_t> inline T readLong();

struct Segment{
    int rL, rR;
    long long len, plen;
};

struct Ask{
    long long j;
    int i, id;
};

const long long INFLL = 1e18 + 2222;
const int Q = 300000 + 1;
const int N = 30000 + 1;
const int C = 5;

ll ways[N][C];

ll cnt(int len, int coins)
{
    ll ans = 0;
    if (0 <= coins && 0 <= len) ans += 1;
    if (1 <= coins && 1 <= len) ans += len - 1;
    if (2 <= coins && 2 <= len) ans += 1ll * (len - 1) * (len - 2) / 2;
    if (3 <= coins && 3 <= len) ans += 1ll * (len - 1) * (len - 2) * (len - 3) / 6;
    if (4 <= coins && 4 <= len) ans += 1ll * (len - 1) * (len - 2) * (len - 3) * (len - 4) / 24;
    return ans;
}

int answer[Q];
vector<Ask> asks[C];
pair<int, int> le[C];
int lesz;
pair<int, int> ri[C];
int risz;

void solve()
{
    int n = readInt(), c = readInt(), q = readInt();

    vector<int> p(n);
    for (int i = 0; i < n; i++)
        p[i] = readInt() - 1;

    vector<deque<Segment> > s(c + 1);

    for (int coins = 0; coins <= c; coins++)
    {
        s[coins].push_back({n, n, 1});
        for (int i = n - 2; i >= 0; i--)
        {
            int me = p[i];
            lesz = 0, risz = 0;
            for (int j = i + 1; j <= i + coins && j < n; j++)
            {
                if (p[j] < me)
                {
                    le[lesz++] = {p[j], j};
                }
                else
                {
                    ri[risz++] = {p[j], j};
                }
            }
            sort(le, le + lesz);
            reverse(le, le + lesz);
            sort(ri, ri + risz);
            for (int j = 0; j < lesz; j++)
            {
                s[coins].push_front({i, le[j].second, ways[n - 1 - le[j].second][coins - le[j].second + i]});
            }
            for (int j = 0; j < risz; j++)
            {
                s[coins].push_back({i, ri[j].second, ways[n - 1 - ri[j].second][coins - ri[j].second + i]});
            }
        }
        for (int i = 0; i < s[coins].size(); i++)
        {
            s[coins][i].plen = s[coins][i].len + (i ? s[coins][i - 1].plen : 0);
        }
    }
    vector<vector<long long> > go(c + 1, vector<long long>(n + 1, INFLL));
    for (int coins = 0; coins <= c; coins++)
    {
        for (int j = (int)s[coins].size() - 1; j >= 0; j--)
        {
            go[coins][s[coins][j].rL] = min(go[coins][s[coins][j].rL], s[coins][j].plen - s[coins][j].len);
        }
    }
    for (int coins = 0; coins <= c; coins++)
    {
        for (int j = n - 1; j >= 0; j--)
        {
            go[coins][j] = min(go[coins][j], go[coins][j + 1]);
        }
    }

    for (int ii = 0; ii < q; ii++)
    {
        answer[ii] = -2;
        int i = readInt() - 1;
        long long j = readLong() - 1;
        if (j >= cnt(n, c))
        {
            answer[ii] = -1;
            continue;
        }
        asks[c].push_back({j, i, ii});
    }
    for (int level = c; level >= 0; level--)
    {
        sort(asks[level].begin(), asks[level].end(), [&](Ask A, Ask B){
             return A.j < B.j;
             });
        int pnt = 0;
        for (auto e : asks[level])
        {
            while (pnt + 1 < s[level].size() && s[level][pnt].plen <= e.j)
                pnt++;
            int L = s[level][pnt].rL;
            int R = s[level][pnt].rR;
            if (e.i <= R)
            {
                if (L <= e.i)
                    answer[e.id] = p[L + R - e.i] + 1;
                else
                    answer[e.id] = p[e.i] + 1;
            }
            else
            {
                int NL = level - (R - L);
                asks[NL].push_back({e.j - s[level][pnt].plen + s[level][pnt].len + go[NL][R + 1], e.i, e.id});
            }
        }
        vector<Ask> z;
        swap(asks[level], z);
    }
    for (int i = 0; i < q; i++)
    {
        printf("%d\n", answer[i]);
    }
    return;
}

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

    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < C; j++)
        {
            ways[i][j] = cnt(i, j);
        }
    }

    int t = readInt();
    while (t--)
    {
        solve();
    }
}

static const int buf_size = 4096;

static char buf[buf_size];
static int len = 0, pos = 0;

inline bool isEof() {
    if (pos == len) {
        pos = 0, len = fread(buf, 1, buf_size, stdin);
        if (pos == len)
        return 1;
    }
    return 0;
}

inline int getChar() {
    return isEof() ? -1 : buf[pos++];
}

inline int peekChar() {
    return isEof() ? -1 : buf[pos];
}

inline int readChar() {
    int c = getChar();
    while (c != -1 && c <= 32)
        c = getChar();
    return c;
}

template <class T>
inline T readInt() {
    int c = readChar();
    T x = 0;
    while ('0' <= c && c <= '9')
        x = x * 10 + c - '0', c = getChar();
    return x;
}

template <class T>
inline T readLong() {
    int c = readChar();
    T x = 0;
    while ('0' <= c && c <= '9')
        x = x * 10 + c - '0', c = getChar();
    return x;
}