#include <vector>
#include <cmath>
#include <execution>
#include<iostream>

using namespace std;
using namespace std::execution;

vector<vector<int>> st;
vector<int> degrees;

struct Request {
    Request() = default;

    Request(int l, int r) : left(l), right(r) {}

    int left;
    int right;
};

vector<int> get_degrees(int N) {
    vector<int> degrees(N + 1);
    int degree = 0;
    int index = 0;
    while (pow(2, degree) <= N) {
        while (index < pow(2, degree + 1) && index <= N) {
            degrees[index] = degree;
            ++index;
        }
        ++degree;
    }
    return degrees;
}

vector<vector<int>> build_sp_table(const vector<int> &arr) {
    st.resize(arr.size());
    for (int i = 0; i < arr.size(); ++i) {
        st[0].push_back(arr[i]);
    }
    int i = 1;
    while (pow(2, i) <= arr.size()) {
        st[i].reserve(arr.size());
        int j = 0;
        int v_left = st[i - 1][j];
        int v_right = st[i - 1][j + pow(2, i - 1)];
        while (j + pow(2, i - 1) < st[i - 1].size()) {
            st[i].push_back(min(v_left, v_right));
            ++j;
            v_left = st[i - 1][j];
            v_right = st[i - 1][j + pow(2, i - 1)];
        }
        ++i;
    }
    return st;
}

int get_min(const Request &req) {
    int R_i = req.right - 1;
    int L_i = req.left;
    int de_max = degrees[R_i - L_i];
    return min(st[de_max][L_i], st[de_max][R_i - pow(2, de_max) + 1]);
}

vector<int> ProcessRequests(const vector<int> &numbers, const vector<Request> &requests) {
    vector<int> res;
    res.resize(requests.size());
    st = build_sp_table(numbers);
    degrees = get_degrees(numbers.size());
    transform(par, requests.begin(), requests.end(), res.begin(), get_min);
    return res;
}