#include <cassert>
#include <cstdio>
#include <iostream>
#include <numeric>
#include <utility>
#include <vector>

using Query = std::pair<int, int>;

void solve_queries(int l, int r, const std::vector<int>& v,
                   const std::vector<Query>& queries,
                   const std::vector<int>& queries_idx,
                   std::vector<int>& answers) {
  if (l == r) {
    for (auto idx : queries_idx) {
      answers[idx] = v[l];
    }
    return;
  }

  int mid = (l + r) / 2;

  std::vector<int> max_left(mid - l + 1), max_right(r - mid);
  max_left[0] = v[mid];
  for (int i = mid - 1; i >= l; --i) {
    max_left[mid - i] = std::min(max_left[mid - 1 - 1], v[i]);
  }
  max_right[0] = v[mid + 1];
  for (int i = mid + 2; i <= r; ++i) {
    max_right[i - mid - 1] = std::min(max_right[i - mid - 2], v[i]);
  }

  std::vector<int> left_queries_idx, right_queries_idx;
  for (int idx : queries_idx) {
    const auto [ql, qr] = queries[idx];
    if (qr <= mid) {
      left_queries_idx.push_back(idx);
    } else if (ql > mid) {
      right_queries_idx.push_back(idx);
    } else {
      int left_max = max_left[mid - ql];
      int right_max = max_right[qr - mid - 1];
      answers[idx] = std::min(left_max, right_max);
    }
  }

  solve_queries(l, mid, v, queries, left_queries_idx, answers);
  solve_queries(mid + 1, r, v, queries, right_queries_idx, answers);
}

int main() {
  assert(freopen("rmq.in", "r", stdin));
  assert(freopen("rmq.out", "w", stdout));

  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);

  int n, q;
  std::cin >> n >> q;
  std::vector<int> v(n);
  for (int& x : v) {
    std::cin >> x;
  }

  std::vector<Query> queries(q);
  for (auto& [l, r] : queries) {
    std::cin >> l >> r;
    --l;
    --r;
  }

  std::vector<int> all_queries_idx(q);
  std::iota(all_queries_idx.begin(), all_queries_idx.end(), 0);
  std::vector<int> answers(q);
  solve_queries(0, n - 1, v, queries, all_queries_idx, answers);

  for (auto x : answers) {
    std::cout << x << "\n";
  }

  return 0;
}