#include <iostream>
#include <fstream>
#include <functional>
#include <utility>
#include <vector>
#include <algorithm>

using namespace std;

template<class DataType>
class Rmq {
		
		function<bool(DataType, DataType)> comp;
		
		vector<DataType> data;
		vector< vector<size_t> > rmq;
		vector<size_t> lg;

		void build() {
			lg.resize(data.size() + 1);
			for (size_t i = 2; i <= data.size(); i++) {
				lg[i] = lg[i >> 1] + 1;
			}
			
			size_t rows = lg[data.size()];

			rmq.resize(rows + 1, vector<size_t>(data.size() + 1));
			for (size_t i = 1; i < data.size(); i++) {
				rmq[0][i] = i;
			}

			for (size_t i = 1; i <= rows; i++) {
				for (size_t j = 1; j < data.size() - (1 << i) + 1; j++) {
					rmq[i][j] = comp(data[rmq[i - 1][j]], data[rmq[i - 1][j + (1 << (i - 1))]]) ? rmq[i - 1][j] : rmq[i - 1][j + (1 << (i - 1))];	
				}
			}
		}
			
	public:

		Rmq(const vector<DataType>& data_, const function<bool(DataType,DataType)>& comp_) {
			data = data_;
			comp = comp_;
			build();
		}

		DataType query(size_t l, size_t r) {
			size_t L = lg[r - l + 1];
			return comp(data[rmq[L][l]], data[rmq[L][r - (1 << L) + 1]]) ? data[rmq[L][l]] : data[rmq[L][r - (1 << L) + 1]];
		}

		size_t queryIndex(size_t l, size_t r) {
			size_t L = lg[r - l + 1];
			return comp(data[rmq[L][l]], data[rmq[L][r - (1 << L) + 1]]) ? rmq[L][l] : rmq[L][r - (1 << L) + 1];
		}
		
};


int main()
{
	ifstream cin("rmq.in");
	ofstream cout("rmq.out");
	int n, m;
	cin >> n >> m;;
	vector<int> v(n + 1);
	for (int i = 1; i <= n; i++) {
		cin >> v[i];
	}

	Rmq<int> rmq(v, less<int>());

	for (int i = 1; i <= m; i++) {
		int a, b;
		cin >> a >> b;
		cout << rmq.query(a, b) << "\n";
	}


	return 0;
}