#include <iostream>
#include <fstream>
#include <vector>
using namespace std;

// sursa care m-a inspirat si la rmq si la arb_int
// https://www.youtube.com/watch?v=ZBHKZF5w4YU

// tare dubioasa este info arena pe teste... de ce varianta pe matrice ia 100 din prima ?? huh ?
ifstream finput ("rmq.in");
ofstream foutput("rmq.out");

vector <int> numere(100001);
vector <int> arb_int(400100);

//void arbore_compunere(int nod , int left, int right)
//{
//    if (left == right)
//        arb_int[nod] = numere[left];
//    else
//    {//completam arborele pe partea stanga atunci cand nu sunt pe cazul de capete egale// moment in care am epuizat cazurile pe acel nod
//        int mij= (left + right) >>1 ;
//        arbore_compunere((nod << 1),left, mij);
//        arbore_compunere(-(~(nod<<1)), mij + 1, right);
////        -(~(nod<<1)) = n/2 +1
//        arb_int[nod] = min(arb_int[nod <<1 ], arb_int[-(~(nod<<1))]);
//    }
//}
//
//
//int min_find(int nod, int arb_left, int arb_right, int start, int finish)
//{
//    // 1<<30 un shift pe biti pentru o val foarte mare pe care s-o asociez in situatia in care
//    // intervalul din arbore nu se suprapune cu intervalul target pentru minim
//    // no overlap
//    if(arb_left > finish || arb_right < start) return 1<<30;
//    // daca intervalul urmarit "inghite" intervalul per nod atunci preiau val din nod
//    //total overlap preiau val din nod
//    if (arb_left >= start && arb_right <= finish)
//        return arb_int[nod];
//    int mij = (arb_left + arb_right) >>1 ;
//    // apelez recursiv min cand am partial overlap
//    // preiau min dintre cele doua parti de arbore in final
//
//    return min(min_find(nod <<1, arb_left, mij, start, finish), min_find(-(~(nod<<1)), mij + 1, arb_right, start, finish));
//}



//int main()
//{
//    int n, m;
//    finput>>n>>m;
//    for(int  i = 1; i <= n; ++i)
//        finput>>numere[i];
//    arbore_compunere(1, 1, n);
//
//    for(int i = 0; i < m; ++i)
//    {
//        int  a, b;
//        finput>>a>>b;
//        foutput<<min_find(1, 1, n, a, b)<<'\n';
//
//    }
//    return 0;
//}

// din motive pe care nici macar eu nu le inteleg am ales sa rulez varianta pe matrice... fiindca nu luam decat 90 la varianta pe arbori cel mmult... which is... ciudat rau
int i,j,n,m,a,b,l,k;
int Matricea_lui_peste[17][100001];

int main()
{
    finput>> n >> m;
    for(i = 1; i <= n; i++)
        finput >> Matricea_lui_peste[0][i];
    for(i = 1; (1 << i) <= n; i++) {
        for(j = 1; j <=  n - (1 << i) + 1; j++){
            Matricea_lui_peste[i][j] = (Matricea_lui_peste[i-1][j] < Matricea_lui_peste[i-1][(1<<(i-1)) + j]) ? Matricea_lui_peste[i-1][j] :  Matricea_lui_peste[i-1][(1<<(i-1))+j];
        }
    }
    for(i = 0; i < m; i++)
    {
        k = 0;
        finput >> a >> b;
        l= b - a + 1;
        while( (1<<(k + 1)) <= l)
            k++;
        foutput << ((Matricea_lui_peste[k][a] < Matricea_lui_peste[k][b-(1<<k) + 1]) ? Matricea_lui_peste[k][a] : Matricea_lui_peste[k][b - (1 << k) + 1] ) << '\n';
    }
    return 0;
}