#include <fstream>
#include <vector>

#include <vector>
#include <cassert>

template<typename _Container_Tp, typename _Combine_Tp>
class SparseTable
{
public:
    using value_type = typename _Container_Tp::value_type;
    using container_type = _Container_Tp;
    using combine_type = _Combine_Tp;

    static size_t lg(size_t n)
    {
        return 63 - __builtin_clzll(n);
    }

    SparseTable(size_t _n, const container_type& _data, combine_type _combine) :
        n(_n), combine(_combine)
    {
        table.push_back(_data);
        for(size_t h = 1; (1 << h) <= n; h++)
        {
            table.push_back(container_type(n - (1 << h)));
            for(size_t i = 0; i + (1 << h) <= n; i++)
                table[h][i] = combine(table[h - 1][i], table[h - 1][i + (1 << (h - 1))]);
        }
    }

    value_type query(size_t x, size_t y)
    {
        if(x > y)
            std::swap(x, y);
        assert(0 <= x && y < n && "SparseTable query out of bounds");

        size_t lgmax = lg(y - x + 1);
        return combine(table[lgmax][x], table[lgmax][y - (1 << lgmax) + 1]);
    }

private:
    size_t n;
    combine_type combine;
    std::vector<container_type> table;
};

int main()
{
    std::ifstream cin("rmq.in");
    std::ofstream cout("rmq.out");

    size_t n, m;
    cin >> n >> m;
    std::vector<unsigned int> a(n);
    for(size_t i = 0; i < n; i++)
        cin >> a[i];
    SparseTable table(n, a, std::min<unsigned int>);
    for(size_t i = 0; i < m; i++)
    {
        size_t x, y;
        cin >> x >> y;
        x--; y--;
        cout << table.query(x, y) << '\n';
    }
}