/*
    author: kartik8800
*/

#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define fr(a,b) for(int i = a; i < b; i++)
#define rep(i,a,b) for(int i = a; i < b; i++)
#define mod 1000000007
#define inf (1LL<<60)
#define all(x) (x).begin(), (x).end()
#define prDouble(x) cout << fixed << setprecision(10) << x
#define triplet pair<ll,pair<ll,ll>>
#define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL)
using namespace std;
#define left(i) (2*i + 1)
#define right(i) (2*i + 2)
#define parent(i) ((i-1)/2)
#include <vector>

template<class T>
class SegmentTree
{
    public:
        //tree constructors.
        SegmentTree(std::vector<T> data, T value, T (*combine)(T obj1, T obj2));
        SegmentTree(T ar[], int n, T value, T (*combine)(T obj1, T obj2));

        //query the range l to r, 0 based array indexing.
        T query(int l, int r);

        //update the element at index idx to val.
        void update(int idx, T val);
        ///TODO lazy propagation
    private:
        //represents the segment tree.
        T *tree;

        //builds the segment tree.
        void buildTree(std::vector<T> data);

        //size of the segment tree array.
        int segTreeSize;

        //extra nodes must be added to array to make its size a power of 2
        //this is the value to be filled for the those nodes.
        T valueForExtraNodes;

        //specifies how to combine child node results to form parent node result.
        T (*combine)(T obj1, T obj2);

        //used to calculate the size of array needed to store the tree.
        int calculateSize(int n);

        //helps to solve a range query.
        T queryHelper(int l,int r, int st, int ed, int node);
};

template<class T> SegmentTree<T>::SegmentTree(std::vector<T> data,
                                                T value, T (*combine)(T obj1, T obj2))
{
   this->combine = combine;
   valueForExtraNodes = value;
   segTreeSize = calculateSize(data.size());
   buildTree(data);
}

template<class T> SegmentTree<T>::SegmentTree(T ar[], int n,
                                            T value, T (*combine)(T obj1, T obj2))
{
   this->combine = combine;
   valueForExtraNodes = value;
   segTreeSize = calculateSize(n);

   std::vector<T> data;
   for(int i = 0; i < n; i++)
         data.push_back(ar[i]);

   buildTree(data);
}


template<class T> int SegmentTree<T>::calculateSize(int n)
{
    int pow2 = 1;
    while( pow2 < n)
    {
        pow2 = pow2 << 1;
    }
    return 2*pow2 - 1;
}

template<class T> T SegmentTree<T>::query(int l, int r)
{
    int st = 0, ed = segTreeSize/2;
    return queryHelper(l, r, st, ed, 0);
}

template<class T> T SegmentTree<T>::queryHelper(int l,int r, int st, int ed, int node)
{
    if( (r < st) || (l > ed) || (l > r) )
        return valueForExtraNodes;
    if(st >= l && ed <= r)
        return tree[node];
    T leftVal = queryHelper(l, r, st, (st + ed)/2, left(node));
    T rightVal = queryHelper(l, r, (st+ed)/2 + 1, ed, right(node));
    return combine(leftVal, rightVal);
}

template<class T> void SegmentTree<T>::buildTree(std::vector<T> data)
{
   int n = data.size();
   tree = new T[segTreeSize];
   int extraNodes = (segTreeSize/2 + 1) - n;
   for(int i = segTreeSize - 1; i >= 0; i--)
   {
       if(extraNodes>0)
           {
               tree[i] = valueForExtraNodes;
               extraNodes--;
           }
       else if(n>0)
           {
               tree[i] = data[n-1];
               n--;
           }
       else
           tree[i] = combine(tree[left(i)], tree[right(i)]);
   }
}

template<class T> void SegmentTree<T>::update(int idx, T val)
{
    int segTreeIdx = (segTreeSize/2) + idx;
    tree[segTreeIdx] = val;
    while(parent(segTreeIdx) >= 0)
    {
        segTreeIdx = parent(segTreeIdx);
        if(right(segTreeIdx) < segTreeSize)
          tree[segTreeIdx] = combine(tree[left(segTreeIdx)], tree[right(segTreeIdx)]);
        if(segTreeIdx == 0)
            break;
    }
}

int large(int x, int y){return max(x,y);}
SegmentTree < int > rangeMaxQueries(vector<int>(),0,large);

int RMQ(int L, int R)
{
    if(L>R)return 0;
    return rangeMaxQueries.query(L,R);
}

void whatsWithThisOPFormat(){
    static int tno = 1;
    cout << "Case #" <<tno++ <<": ";
}

int solve(vector<int>& v, int strt, int k)
{
    if(k == 1)return strt;

    // binary search left region
    int lo = 1, hi = strt - 1;
    while(lo <= hi){
        int mid = (lo+hi)/2;
        int rightRoom = k + mid - 1;

        if(rightRoom < strt)
            lo = mid + 1;

        else if(rightRoom > (int)v.size() - 1)
            hi = mid -1;

        else{
            bool reachRight1st = (RMQ(mid, strt - 1) > RMQ(strt, rightRoom - 1)) ? 1 : 0;
            bool reachMid = (RMQ(mid, strt - 1) < RMQ(strt, rightRoom)) ? 1 : 0;
            if(reachMid && reachRight1st)
                return mid;
            else if(reachMid)
                hi = mid - 1;
            else lo = mid + 1;
        }
    }

    // binary search right region
    lo = strt+1, hi = (int)v.size() - 1;
    while(lo <= hi){

        int mid = (lo+hi)/2;
        int leftRoom = mid - k + 1;

        if(leftRoom > strt)
            hi = mid - 1;
        else if(leftRoom <= 0)
            lo = mid+1;

        else{
            bool reachLeft1st = (RMQ(leftRoom, strt - 1) < RMQ(strt, mid - 1)) ? 1 : 0;
            bool reachMid = (RMQ(leftRoom - 1, strt - 1) > RMQ(strt, mid - 1)) ? 1 : 0;
            if(reachMid && reachLeft1st)
                return mid;
            else if(reachMid)
                lo = mid + 1;
            else hi = mid - 1;
        }
    }
    return -1;
}

int main() {
   fast_io;
   ll t,n,m,x,i,j,k,q;
   cin >> t;
   //t = 1;
   while(t--)
   {
        cin >> n >> q;
        vector<int> difficulty(n+1);

        fr(1,n)
            cin >> difficulty[i];
        difficulty[0] = difficulty[n] = 1e9;

        rangeMaxQueries = SegmentTree<int>(difficulty,0,large);
        vector<int> ans;
        while(q--){
            int strt, k;
            cin >> strt >> k;
            ans.push_back(solve(difficulty, strt, k));
        }

        whatsWithThisOPFormat();
        for(int x : ans)cout << x <<' ';
        cout << '\n';
   }
   return 0;
}