#include <iostream>
#include <vector>
#include <fstream>

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

using namespace std;

// RMQ

int RMQ(int i, int j, int **M, int* v)
{
  if (i > j)
    return 0x3f3f3f3f;

  if (i == j)
    return M[i][0];

  if (i + 1 == j)
    return M[i][1];

  int p, log2;
  for (log2 = 1, p = 2; p + i <= j; p *= 2, log2++)
    ;
  log2--;
  p /= 2;

  int min = RMQ(i + p, j, M, v);
  return v[min] < v[M[i][log2]] ? (min) : (M[i][log2]);
}

void Preprocesare(int **M, int *v, int n)
{
  for (int i = 0; i < n; i++)
    M[i][0] = i;
  
  for (int j = 1; 1 << j <= n; j++)
  {
    for (int i = 0; i + (1 << j) - 1 < n; i++)
    {
      if (v[M[i][j - 1]] <= v[M[i + (1 << j - 1)][j - 1]])
        M[i][j] = M[i][j - 1];
      else
        M[i][j] = M[i + (1 << j - 1)][j - 1];
    }
  }
}

int main()
{
  int n, m, *v;
  fin >> n >> m;
  v = new int[n];
  int log2, p;

  for (log2 = 1, p = 2; p <= n; log2++, p *= 2)
    ;

  int **M = new int *[n];
  for (int i = 0; i <= n; i++)
    M[i] = new int[log2];

  for (int i = 0; i < n; i++)
  {
    fin >> v[i];
  }
  
  for (int i = 0; i < n; i++)
  {
    for (int j = 0; j < log2; j++)
      M[i][j] = 0x3f3f3f3f;
  }
  Preprocesare(M, v, n);

  for (int i = 0; i < m; i++)
  {
    int p, q;
    fin >> p >> q;
    p--, q--;
    // raspuns
    fout << v[RMQ(p, q, M, v)] << endl;
  }

  for (int i = 0; i < n; i++)
  {
    delete[] M[i];
  }
  delete[] M;
  delete[] v;
  return 0;
}

// Heapuri

// int father(int k)
// {
//   return (k - 1) / 2;
// }

// int left_son(int k) {
//   return 2 * k + 1;
// }

// int right_son (int k)
// {
//   return 2 * k + 2;
// }

// void Percolate(vector<int> &h, vector<int> &o)
// {
//   int k = h.size() - 1;

//   while (k > 0 && h[k] < h[father(k)])
//   {
//     swap(h[k], h[father(k)]);
//     swap(o[k], o[father(k)]);
//     k = father(k);
//   }
// }

// void Sift(vector<int> &h, vector<int> &o, int k)
// {
//   int son;
//   int size = h.size();
//   do {
//     son = 0;
//     if (left_son(k) < size){
//         son = left_son(k);
//       if(right_son(k) < size && h[son] > h[right_son(k)])
//         son = right_son(k);
//       if (h[son] >= h[k])
//         son = 0;
//     }

//     if(son){
//       swap(h[son], h[k]);
//       swap(o[son], o[k]);
//       k = son;
//     }
//   } while(son);
// }

// void Insereaza(vector<int> &h, vector<int> &o, int val, int ord)
// {
//   h.push_back(val);
//   o.push_back(ord);
//   Percolate(h, o);
// }

// void AfiseazaVal(vector<int> h)
// {
//   fout << h[0] << endl;
// }

// void Elimina(vector<int>& h, vector<int> o, int poz)
// {
//   swap(h[poz], h[h.size() - 1]);
//   swap(o[poz], o[o.size() - 1]);
//   h.pop_back();
//   o.pop_back();
//   if (poz > 0 && h[poz] < h[father(poz)]){
//     swap(h[poz], h[h.size() - 1]);
//     swap(o[poz], o[o.size() - 1]);
//     Percolate(h, o);
//   }
//   else
//     Sift(h, o, poz);
// }

// int main()
// {
//   vector<int> heap;
//   vector<int> ordine;
//   // Insereaza(heap, 3);
//   // Insereaza(heap, 5);
//   // Insereaza(heap, 4);
//   // Insereaza(heap, 1);
//   // Insereaza(heap, 10);
//   // Insereaza(heap, 9);
//   // Insereaza(heap, 4);
//   // Insereaza(heap, 2);
//   // for (int i = 0; i < heap.size(); i ++)
//   //   cout << heap[i] << " ";
//   int n;
//   fin >> n;
//   int cnt = 1;
//   for (int i = 1; i <= n; i++)
//   {

//     int comanda;
//     fin >> comanda;
//     switch (comanda)
//     {
//     case 1:
//     {
//       int valoare;
//       fin >> valoare;
//       Insereaza(heap, ordine, valoare, cnt++);
//       break;
//     }
//     case 2:
//     {
//       int valoare;
//       fin >> valoare;
//       int j;
//       for (j = 0; j < ordine.size(); j ++)
//         if (ordine[j] == valoare)
//         {
//           break;
//         }
//       Elimina(heap, ordine, j);
//       break;
//     }
//     case 3:
//     {
//       AfiseazaVal(heap);
//       break;
//     }
//     }
//   }
//   return 0;
// }