#include <iostream>
#include <fstream>
#include <vector>
#include <cmath>
#include <algorithm>


typedef std::vector< std::vector<int> > matrix;

matrix preComputeRmq(std::vector<int> &v)
{
    matrix rmq_D(v.size());

    size_t lg = static_cast<std::size_t>(log(v.size())/log(2)) + 1;
    for (matrix::iterator it = rmq_D.begin(); it != rmq_D.end(); ++it)
        it->reserve(lg);

    for (std::size_t i = 0; i < v.size(); ++i)
        rmq_D[i][0] = v[i];

    for (std::size_t i = 1; i < lg; ++i)
        for (std::size_t j = 0; j + (1 << i) - 1 < v.size(); ++j)
            rmq_D[j][i] = std::min(rmq_D[j][i - 1],
                                   rmq_D[j + (1 << (i - 1))][i - 1]);

    return rmq_D;
}

int main()
{
    std::ifstream fin("rmq.in");
    std::ofstream fout("rmq.out");

    int N, M;
    fin >> N >> M;

    std::vector<int> v(N);
    for (std::vector<int>::iterator it = v.begin(); it != v.end(); ++it)
        fin >> *it;

    matrix rmq_D = preComputeRmq(v);
    for (; M--; ) {
        int i, j;
        fin >> i >> j;
        --i, --j;

        int k = static_cast<std::size_t>(log(j - i + 1)/log(2));
        fout << std::min(rmq_D[i][k], rmq_D[j - (1 << k) + 1][k]) << "\n";
    }

    fin.close();
    fout.close();

    return 0;
}