#define _CRT_SECURE_NO_WARNINGS
#include <iostream>

int table[100001][17], n,m;
int logaritm[100001];
 

class InParser
{
private:
	FILE* fin;
	char* buffer;
	size_t SIZE = 4096;
	int buffer_index;
	char get_char()
	{
		++buffer_index;
		if (buffer_index == SIZE)
		{
			size_t count = fread(buffer, 1, SIZE, fin);
			if (count < SIZE)buffer[count] = 0;
			buffer_index = 0;
		}
		return buffer[buffer_index];
	}
public:
	InParser(const char* name)
	{
		fin = fopen(name, "r");
		buffer = new char[SIZE];
		memset(buffer, 0, SIZE);
		buffer_index = SIZE - 1;
	}
	~InParser()
	{
		fclose(fin);
		delete[] buffer;
	}

	InParser& operator >>(uint32_t& x)
	{
		char c = get_char();
		while (!isdigit(c))
			c = get_char();

		x = c - '0';
		while (isdigit(c = get_char()))
			x = x * 10 + c - '0';
		return *this;
	}
	InParser& operator >>(int& x)
	{
		char c;
		while (!isdigit(c = get_char()));

		x = c - '0';
		while (isdigit(c = get_char()))
			x = x * 10 + c - '0';
		return *this;
	}
}f("rmq.in");


class OutParser
{
private:
	FILE* fout;
	char* buffer;
	int buffer_index;
	const int SIZE = 4096;
	void print_char(char c)
	{
		if (buffer_index == SIZE)
		{
			fwrite(buffer, 1, SIZE, fout);
			buffer_index = 0;
		}
		buffer[buffer_index++] = c;
	}
public:
	OutParser(const char* name)
	{
		fout = fopen(name, "w");
		buffer_index = 0;
		buffer = new char[SIZE];
		memset(buffer, 0, SIZE);
	}
	~OutParser()
	{
		fwrite(buffer, 1, buffer_index, fout);
		fclose(fout);
		delete[] buffer;
	}
	OutParser& operator <<(int x)
	{
		if (x < 10)
			print_char('0' + x);
		else
		{
			*this << x / 10;
			print_char('0' + x % 10);
		}
		return *this;
	}

	OutParser& operator <<(char c)
	{
		print_char(c);
		return *this;
	}

	OutParser& operator <<(const char* c)
	{
		while (*c)
		{
			print_char(*c);
			++c;
		}
		return *this;
	}
}g("rmq.out");

int main()
{
	f >> n >> m;
	for (int i = 1; i <= n; ++i)
		f >> table[i][0];

	logaritm[1] = 0;
	for (int i = 2; i <= n; ++i)
		logaritm[i] = 1 + logaritm[i / 2];

	for (int j = 1; j <= logaritm[n]; ++j)
		for (int i = 1; i + (1 << j) - 1 <= n; ++i)
			table[i][j] = std::min(table[i][j - 1], table[i + (1 << (j - 1))][j - 1]);

	int x, y, len;

	for (int i = 0; i < m; ++i)
	{
		
		f >> x >> y;
		len = logaritm[y - x + 1];
		g << std::min(table[x][len], table[y - (1 << len) + 1][len]) << '\n';
	}
	
}