#include<bits/stdc++.h>
using namespace std;

typedef long long int ll;
#define IOS ios_base::sync_with_stdio(0);  cin.tie(0); cout.tie(0);


#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;

typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>order_set;
typedef pair<int, int>pr;
#define all(i)     i.begin() , i.end()
#define ft     first
#define sn     second
#define pb push_back

#define dbg cout<<"rony\n"
#define en "\n"

#define MAXN 100010
#define inf 1e6+5
const ll mod = 1e9 + 7;

int n, c, q;
int a[MAXN];

struct SegmentTree
{
    struct node
    {
        int preval, sufval, precnt, sufcnt, an, suru, ses;
        void init(int l, int r)
        {
            suru = l, ses = r;
            if (l == r) {
                preval = sufval = a[l];
                an = precnt = sufcnt = 1;
            }
        }
    } g[4 * MAXN], ans;

    node fill_cn(int l, int r, node B, node C)
    {
        node A;

        if (B.preval == -1) {
            return C;
        }
        if (C.preval == -1) return B;
        if (B.preval == C.sufval) {
            A.preval = B.preval; A.sufval = B.sufval;
            A.precnt = B.precnt + C.precnt;
            A.sufcnt = B.sufcnt + C.sufcnt;
            A.an = A.precnt;
        }
        else if (B.preval == B.sufval && B.sufval == C.preval) {
            A.preval = B.preval; A.sufval = C.sufval;
            A.precnt = B.precnt + C.precnt;
            A.sufcnt = C.sufcnt;
            A.an = max({B.an, C.an, A.precnt});
        }
        else if (B.sufval == C.preval && C.sufval == C.preval) {
            A.preval = B.preval; A.sufval = B.sufval;
            A.precnt = B.precnt; A.sufcnt = B.sufcnt + C.precnt;
            A.an = max({B.an, C.an, A.sufcnt});
        }
        else if (B.sufval == C.preval) {
            A.preval = B.preval; A.sufval = C.sufval;
            A.precnt = B.precnt; A.sufcnt = C.sufcnt;
            A.an = max({B.an, C.an, B.sufcnt + C.precnt });
        }
        else {
            A.preval = B.preval; A.sufval = C.sufval;
            A.precnt = B.precnt; A.sufcnt = C.sufcnt;

            A.an = max({B.an, C.an, B.sufcnt, C.precnt});
        }

        return A;
    }

    void build(int cn, int l, int r)
    {
        g[cn].init(l, r);
        if (l == r) return ;
        int md = l + (r - l) / 2;
        build(cn * 2, l, md);
        build(cn * 2 + 1, md + 1, r);

        g[cn] = fill_cn( l, r, g[cn * 2], g[cn * 2 + 1]);
        g[cn].suru = l; g[cn].ses = r;
    }

    node makend()
    {
        node A;
        A.preval = A.sufval = A.precnt = A.sufcnt = A.an = -1;
        return A;
    }

    node query(int cn, int l, int r)
    {
        int x = g[cn].suru;
        int y = g[cn].ses;
        if (y < l || x > r ) {

            return makend();
        }
        if (l <= x && y <= r) {

            return g[cn];
        }
        node _1 = query( cn * 2, l, r);
        node _2 = query(cn * 2 + 1, l, r);
        return fill_cn(x, y, _1, _2);
    }

} stre;

void solve()
{
    cin >> n >> c >> q;

    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }

    stre.build(1, 1, n);
    // dbg; dbg;
    while (q--)
    {
        int x, y;
        cin >> x >> y;
        stre.ans = stre.query(1, x, y);
        cout << stre.ans.an << en;
    }
    // stre.ans = stre.query(1, 7, 7);
    // cout << stre.ans.an << en;

}
int main()
{
    IOS;
    ll t;
    t = 1;
    cin >> t;

    ll c = 0;
    while ( t-- )
    {
        cout << "Case " << ++c << ":\n";
        solve();
    }
    return 0;
}