#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;
};


using namespace std;

int n;
vector<int> a;     //массив
vector<int> tree(1e9);  //дерево отрезков. в вершинах хранятся минимумы

void build_tree(int v, int tl, int tr) {
    if (tl == tr) {
        tree[v] = a[tl];
    } else {
        int tm = (tl + tr) / 2;
        build_tree(v * 2 + 1, tl, tm);
        build_tree(v * 2 + 2, tm + 1, tr);
        tree[v] = min(tree[v * 2 + 1], tree[v * 2 + 2]);    //сохраняем минимум вместо суммы
    }
}

//Запрос минимума
int get_min(int l, int r, int v, int tl, int tr) {
    //вариант 1
    if (l <= tl && tr <= r) {
        return tree[v];
    }

    //вариант 2
    if (tr < l || r < tl) {
        return INT64_MAX;     //Значение, которое не повлияет на общий минимум
    }

    //вариант 3
    int tm = (tl + tr) / 2;
    return min(get_min(l, r, v * 2 + 1, tl, tm),    //минимум вместо суммы.
               get_min(l, r, v * 2 + 2, tm + 1, tr));
}

void update(int idx, int val, int v, int tl, int tr) {
    //вариант 1
    if (idx <= tl && tr <= idx) {       //То же, что и idx == tl == tr
        a[idx] = val;
        tree[v] = val;
        return;
    }

    //вариант 2
    if (tr < idx || idx < tl) {
        return;
    }

    //вариант 3
    int tm = (tl + tr) / 2;
    update(idx, val, v * 2, tl, tm);
    update(idx, val, v * 2 + 1, tm + 1, tr);
    tree[v] = min(tree[v * 2], tree[v * 2 + 1]);    //минимум вместо суммы.
}

int start_get(const Request &req) {
    int R_i = req.right - 1;
    int L_i = req.left;
//    auto tmp = get_min(R_i, L_i, 1, 0, a.size() - 1);
    return get_min(R_i, L_i, 0, 0, a.size() - 1);
}

vector<int> ProcessRequests(const vector<int> &numbers, const vector<Request> &requests) {
    a = numbers;
    build_tree(1, 0, numbers.size() - 1);
    vector<int> res;
    res.resize(requests.size());
    transform(par, requests.begin(), requests.end(), res.begin(), start_get);
    return res;