;
 ;
 ;
 ;
 const int maxV=1e9;

 int bucket[bktCount][bktSize];
 int unOrdered[bktSize*bktCount];
 int ordered[bktSize*bktCount];
 int N,K;

 #include <cstdio>
 #include <cstring>
 #include <algorithm>

 void init()
 {
     scanf("%d%d",&N,&K);
     memset(bucket[N>>bktDigit],0x7f,sizeof(bucket[N>>bktDigit]));
     ;i<N;i++)
     {
         scanf("%d",unOrdered+i);
         ordered[i]=unOrdered[i];
         bucket[i>>bktDigit][i&bktMaxIdx]=unOrdered[i];
     }

     using std::sort;
     int bktUsed=N>>bktDigit;
     sort(ordered,ordered+N);
     ;i<=bktUsed;i++) sort(bucket[i],bucket[i]+bktSize);
 }

 inline void enumerate(int _rangeL,int _rangeR,int _val,int& _notMore)
 {
     for(int i=_rangeL;i<=_rangeR;i++)
         if(unOrdered[i]<=_val) ++_notMore;
 }

 inline void countBucket(int _bktIdx,int _val,int& _notMore)
 {
     using std::upper_bound;

     int* ub=upper_bound(bucket[_bktIdx],bucket[_bktIdx]+bktSize,_val);
     _notMore+=(ub-bucket[_bktIdx]);
 }

 int ask(int _rangeL,int _rangeR,int _k) //k-th smallest
 {
     int digitL=_rangeL>>bktDigit;
     int digitR=_rangeR>>bktDigit;
     ;
     ;

     while(vL<vR)
     {
         ;
         ;
         if(digitL==digitR)
             enumerate(_rangeL,_rangeR,ordered[midV],notMore);
         else
         {
             ;i<digitR;i++)
                 countBucket(i,ordered[midV],notMore);
             enumerate(_rangeL,((digitL+)<<bktDigit)-,ordered[midV],notMore);
             enumerate(digitR<<bktDigit,_rangeR,ordered[midV],notMore);
         }

         ;
         else vR=midV;
     }
     return ordered[vL];
 }

 int main()
 {
     init();
     ;i<K;i++)
     {
         int l,r,k;
         scanf("%d%d%d",&l,&r,&k);
         printf(,r-,k));
     }
     ;
 }