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

/* This is an O(n) precalculation, O(1) query RMQ implementation.
 * I learned about this method from Andrei-Costin Constantinescu */
template <typename T, T inf, typename Cmp>
class range_min_query{
    Cmp c;
    int n, k;
    std::vector<unsigned long long> msk;
    std::vector<T> buf;

    T& get(int niv, int j){
        return buf[n + (n / 64) * niv + j];
    }

    T small_query(int st, int dr){
        return st >= dr ? inf : buf[st + 63 - __builtin_clzll(msk[st] & ((unsigned long long)-1ll >> (64 - dr + st)))];
    }

    T large_query(int st, int dr){
        if(st >= dr) return inf;
        const int niv = 31 - __builtin_clz(dr - st);
        return std::min<T, Cmp>(get(niv, st), get(niv, dr - (1 << niv)), c);
    }

    T brut(int st, int dr){
        T ret = inf;
        for(int i = st; i < dr; ++i) ret = min<T, Cmp>(ret, buf[i], c);
        return ret;
    }
public:
    range_min_query(): n(0), msk(), buf() {}

    template <typename F>
    range_min_query(int N, F f, Cmp C): c(C), n(N), k(31 - __builtin_clz(n / 64)), msk(n + 1, 0), buf(n + (k + 1) * n / 64 + 1){
        for(int i = 0; i < n; ++i) buf[i] = f(i);
        for(int i = n - 1; i >= 0; msk[i--] |= 1)
            for(msk[i] = 2 * msk[i + 1]; msk[i] && !c(buf[i + __builtin_ctzll(msk[i])], buf[i]); )
                msk[i] ^= (msk[i]&-msk[i]);

        for(int i = 0; i + 64 <= n; i += 64)
            get(0, i / 64) = small_query(i, i + 64);


        for(int niv = 1; niv <= k; ++niv)
            for(int i = 0, j = 1 << (niv - 1); j <= n / 64; ++i, ++j)
                get(niv, i) = std::min<T, Cmp>(get(niv - 1, i), get(niv - 1, j), c);
    }

    T query(int st, int dr){
        return std::min<T, Cmp>({ small_query(st, std::min(st + 64, dr)), small_query(std::max(dr - 64, st), dr), 
                large_query((st + 63) / 64, dr / 64) }, c);
    }
};

int main(){
    ifstream f("rmq.in");
    ofstream g("rmq.out");
    int n, m;
    f >> n >> m;

    range_min_query<int, 1000000000, less<int>> rmq(n, [&](int){ int x; f >> x; return x; }, less<int>());

    for(int x, y; m && f >> x >> y; --m)
        g << rmq.query(x - 1, y) << '\n';
}