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

#include <bits/stdc++.h>

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, tl, tm);
        build_tree(v * 2 + 1, tm + 1, tr);
        tree[v] = min(tree[v * 2], tree[v * 2 + 1]);    //сохраняем минимум вместо суммы
    }
}

//Запрос минимума
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 INT_MAX;     //Значение, которое не повлияет на общий минимум
    }

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

int main() {
    const vector<int> numbers = {3, 1, 0, 4};
    const vector<Request> requests = {
            {0, 4},
            {0, 2},
            {1, 3},
            {3, 4}
    };
    for (int result: ProcessRequests(numbers, requests)) {
        cout << result << " ";
    }
    cout << endl;
}