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

int counter = 0;

struct Request {
    int left;
    int right;
};

struct node{
public:
    int L, R, val;

    node(int L = -1, int R = -1, int val = INT32_MAX){
        this->L = L;
        this->R = R;
        this->val = val;
    }

    ~node() = default;
};

std::vector<node> tree;

int init_node(int indx, int L, int R, const std::vector<int>& init_array){
    if (L == R) {
        if (counter < init_array.size())
            tree[indx] = {L, R, init_array[counter]};
        else
            tree[indx] = {L, R, INT32_MAX};
        counter++;
        return tree[indx].val;
    }
    int l = init_node(indx * 2 + 1, L,L + (R - L) / 2 , init_array);
    int r = init_node(indx * 2 + 2, L + (R - L) / 2  + 1, R, init_array);
    tree[indx] = node(L,R, std::min(l,r));
    return tree[indx].val;
}

void init(const std::vector<int>& init_array) {
    int n = log2(init_array.size());
    if ( 1 << n != init_array.size())
        n ++;
    int K = 1 << n;
    tree.resize(K*2 - 1);
    int a = init_node(0, 0, K - 1, init_array);
    tree[0] = {0, K - 1, a};
}

int gets(int indx, int L, int R) {
    if (R >= tree[indx].R && L <= tree[indx].L)
        return tree[indx].val;
    if (R < tree[indx].L || L > tree[indx].R)
        return INT32_MAX;
    return std::min(gets(indx * 2 + 1, L, R), gets(indx * 2 + 2, L, R));
}

int get(Request req) {
    return gets(0, req.left, req.right - 1);
}


std::vector<int> ProcessRequests(const std::vector<int>& numbers, const std::vector<Request>& requests){
    std::vector<int> ans(requests.size());
    init(numbers);
    std::transform(std::execution::par, requests.begin(), requests.end(), ans.begin(), [](Request r){return get(r);});
    return ans;

}