#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

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) / 2;
        arbore_compunere(nod * 2,left, mij);
        arbore_compunere(nod * 2 + 1, mij + 1, right);
        arb_int[nod] = min(arb_int[nod * 2], arb_int[nod * 2 + 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) / 2;
    // apelez recursiv min cand am partial overlap
    // preiau min dintre cele doua parti de arbore in final
    return min(min_find(nod * 2, arb_left, mij, start, finish), min_find(nod * 2 + 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;
}