#include <iostream>
#include <vector>
#include <functional>
#include <set>
#include <algorithm>
#include <stack>
#include <unordered_map>
#include <iomanip>
#include <limits>
std::tuple<int> readInt1(){
int a;
std::cin >> a;
return {a};
}
std::tuple<int,int> readInt2(){
int a, b;
std::cin >> a >> b;
return {a,b};
}
std::tuple<int,int,int> readInt3(){
int a, b, c;
std::cin >> a >> b >> c;
return {a,b,c};
}
std::vector<int> readVecInt(int n){
std::vector<int> arr(n);
for (int i = 0; i < n; i++){
int a;
std::cin >> a;
arr[i] = a;
}
return arr;
}
std::vector<long long> readVecLong(int n){
std::vector<long long> arr(n);
for (int i = 0; i < n; i++){
long long a;
std::cin >> a;
arr[i] = a;
}
return arr;
}
std::vector<std::tuple<int,int>> readVecTup2(int n){
std::vector<std::tuple<int,int>> arr(n);
for (int i = 0; i < n; i++){
int a, b;
std::cin >> a;
std::cin >> b;
arr[i] = {a,b};
}
return arr;
}
std::vector<std::tuple<int,int,int>> readVecTup3(int n){
std::vector<std::tuple<int,int,int>> arr(n);
for (int i = 0; i < n; i++){
int a, b, c;
std::cin >> a;
std::cin >> b;
std::cin >> c;
arr[i] = {a,b,c};
}
return arr;
}
void printNewLine(){std::cout << "\n";}
template<typename T, typename... Ts>
std::tuple<Ts...> tail(std::tuple<T,Ts...> as){
return std::apply([](T &a, Ts... b){return std::make_tuple(b...);},as);
}
template<typename T>
void print(T a){std::cout << std::setprecision(19) << a;}
template<typename... T>
void println(T... a);
template<typename T, typename Ts>
void print(std::tuple<T,Ts> a){
print(std::get<0>(a));
print(" ");
print(std::get<1>(a));
}
template<typename T, typename... Ts>
void print(std::tuple<T,Ts...> a){
print(std::get<0>(a));
print(" ");
print(tail(a));
}
template<typename T>
void print(const std::vector<T> &arr, int width = -1){
if (width == -1) width = arr.size();
for (int i = 0; i < (int)arr.size(); i++){
if ((i%width) == width-1 && i != (int)arr.size()-1){
print(" ");
println(arr[i]);
}else if ((i%width) == 0){
print(arr[i]);
}else {
print(" ");
print(arr[i]);
}
}
}
template<typename... T>
void println(T... a){print(a...);printNewLine();}
template<typename T>
void sorted(std::vector<T> &arr){
std::sort(arr.begin(),arr.end(),[](const T &a, const T &b){ return a < b; });
}
template<typename T>
std::set<T> toSet(const std::vector<T> &vec){
std::set<T> c;
for (T a : vec){ c.emplace(a);}
return c;
}
template<typename T, typename N>
std::vector<N> map(const std::vector<T> &a, const std::function<N(T)> &transform){
std::vector<N> b(a.size());
int i = 0;
for (T x : a){
b[i] = transform(x);
i++;
}
return b;
}
template<typename N, typename M, typename R>
std::vector<R> zip(const std::vector<N> &a, const std::vector<M> &b, const std::function<R(N,M)> &transform){
int n = std::min(a.size(),b.size());
std::vector<R> res(n);
for (int i = 0; i < n; i++){
res[i] = transform(a[i],b[i]);
}
return res;
}
template<typename T, typename N>
std::vector<N> convertVec(const std::vector<T> &a){
std::vector<N> b(a.size());
int i = 0;
for (T x : a){
b[i] = x;
i++;
}
return b;
}
template<typename T>
std::vector<T> reverse(const std::vector<T> &a){
std::vector<T> b(a.size());
int i = 0;
for (T x : a){
b[a.size()-1-i] = x;
i++;
}
return b;
}
template<typename T, typename R>
R reduce(const std::vector<T> &arr, R init, const std::function<R(const R,const T)> &transform){
R current = init;
for (int idx = 0; idx < (int)arr.size(); idx++){
current = transform(current,arr[idx]);
};
return current;
}
template<typename T>
T max(const std::vector<T> &arr){return reduce(arr, arr[0], static_cast<std::function<T(const T,const T)>>(static_cast<const T& (*)(const T&, const T&)>(std::max<T>)));}
template<typename T>
T min(const std::vector<T> &arr){return reduce(arr, arr[0], static_cast<std::function<T(const T,const T)>>(static_cast<const T& (*)(const T&, const T&)>(std::min<T>)));}
template<typename T>
std::function<T(const T,const T)> add(){return [](T a,T b){return a+b;};}
template<typename T>
std::function<T(const T,const T)> modAdd(T mod){return [mod](T a,T b){return (((a+b)%mod)+mod)%mod;};}
template<typename T, typename R>
std::function<R(const R,const T)> mulAdd(R mul){return [mul](R a,T b){return a+b*mul;};}
template<typename T>
T sum(const std::vector<T> &arr){return reduce(arr, 0, add<T>());}
template<typename T>
T avg(const std::vector<T> &arr){return reduce(arr, 0.0, mulAdd<double,T>(1.0/arr.size()));}
template<typename T>
T binarySearch(T min, T max, const std::function<bool(T)> &leq){
if (min == max) return max;
T guess = (min+max)/2;
if (leq(guess)){
return binarySearch(min,guess,leq);
}else{
return binarySearch(guess+1,max,leq);
}
}
template<typename T>
T binarySearchDecending(T min, T max, const std::function<bool(T)> &leq){
std::function<bool(T)> gt = [leq](T x){
return !leq(x);
};
return binarySearch(min,max+1, gt)-1;
}
template<typename T>
std::vector<T> cloneVec(std::vector<T> a){return a;}
template<typename T>
std::vector<T> padding(const std::vector<T> &initial, T num, int start, int end){
std::vector<T> arr(start+initial.size()+end);
for (int i = 0; i < start; i++){
arr[i] = num;
}
for (int i = 0; i < (int)initial.size(); i++){
arr[start+i] = initial[i];
}
for (int i = 0; i < end; i++){
arr[start+initial.size()+i] = num;
}
return arr;
}
template<typename T>
int findMax(int start, int end, const std::function<T(int)> &maxHeuristic){
T initialGuess = maxHeuristic(start);
int index = start;
for (int i = start; i <= end; i++){
if (initialGuess < maxHeuristic(i)){
initialGuess = maxHeuristic(i);
index = i;
}
}
return index;
}
template<typename T>
void operateOnMax(int start, int end, const std::function<T(int)> &maxHeuristic, const std::function<void(int)> &found){
found(findMax(start,end,maxHeuristic));
}
template<typename T>
void stackOperate(T init, const std::function<std::vector<T>(T)> operate){
std::stack<T> stack;
stack.push(init);
while (!stack.empty()){
T next = stack.top();
stack.pop();
std::vector<T> nextSteps = operate(next);
for (T a : nextSteps){
stack.push(a);
}
}
}
template<typename T>
void recursiveVectorSplit(int start, int end, int distl, int distr, const std::function<T(int)> &maxHeuristic, const std::function<void(int)> &found){
if (start == end){
return found(start);
}else if (end < start){
return;
}
std::tuple<int,int> range = {start,end};
std::function<std::vector<std::tuple<int,int>>(std::tuple<int,int>)> splitter = [distl, distr,&maxHeuristic,&found](std::tuple<int,int> range){
auto [start,end] = range;
int idx = findMax(start, end, maxHeuristic);
found(idx);
std::vector<std::tuple<int,int>> next;
if (idx+distl+1 <= end){
next.push_back({idx+distl+1,end});
}
if (start <= idx-distr-1){
next.push_back({start, idx-distr-1});
}
return next;
};
stackOperate(range,splitter);
}
template<typename T>
std::vector<T> dynamicallyComputableList(int n, std::function<T(std::vector<T>&,int)> next){
std::vector<T> arr(n);
for (int i = 0; i < n; i++){
arr[i] = next(arr,i);
}
return arr;
}
template<typename T>
int indexOfBinarySearch(const std::vector<T> &arr, const T &find){
return binarySearch(0,(int)arr.size()-1,(std::function<bool(int)>)[&arr, &find](int guess){return find <= arr[guess];});
}
template<typename T>
std::unordered_map<T, int> indexCompress(const std::vector<T> &arr){
std::unordered_map<T, int> compressed;
int i = 0;
for (T x : arr){
if (compressed.find(x) != compressed.end()) compressed[x] = i++;
}
return compressed;
}
template<typename T>
std::tuple<T, std::vector<int>> shortestPathDirected(const std::vector<std::tuple<int, int, T>> &edgesMessy, int start, int goal){
//assumes all are between 0 <= n < c*(number of vertexies), where c is reasonably small constant.
std::vector<int> vertexies = {};
for (auto& [s,g,c] : edgesMessy){
vertexies.push_back(s);
vertexies.push_back(g);
}
std::vector<std::tuple<int, int, T>> edges = edgesMessy;
int mappedStart = start;
int mappedEnd = goal;
int n = max(vertexies)+1;
std::vector<T> distance(n);
std::vector<int> path(n);
for (int i = 0; i < n; i++) distance[i] = std::numeric_limits<T>::max()/4;
for (int i = 0; i < n; i++) path[i] = i;
distance[mappedStart] = 0;
for (int i = 1; i <= n; i++) {
bool changed = false;
for (auto e : edges) {
auto [a, b, w] = e;
if (!changed) {changed = (distance[b] != std::min(distance[b], distance[a]+w));}
if (distance[a]+w < distance[b]){
distance[b] = distance[a]+w;
path[b] = a;
}
}
if (!changed) break;
if (changed && i == n){
// handle inifnite loop This could be made to find the infinite loop instead.
return std::tuple((T)0,(std::vector<int>){});
}
}
std::vector<int> fullPath = {goal};
while (fullPath[fullPath.size()-1] != start){
fullPath.push_back(path[fullPath[fullPath.size()-1]]);
}
return std::tuple(distance[mappedEnd],reverse(fullPath));
}
void marioKart2(){
auto [n,k] = readInt2();
auto arr = readVecLong(n);
int start = 0;
int goal = n;
std::vector<std::tuple<int, int, double>> edges;
for (int i = 0; i < n; i++){
std::tuple<int,int,double> a = {i, i+1,1.0};
edges.push_back(a);
if (i+arr[i]+k <= n){
std::tuple<int,int,double> b = {i, i+(arr[i])+k,(double)(k+1)};
edges.push_back(b);
}else if (i+arr[i] <= n){
int dist = n-(i+(arr[i]));
std::tuple<int,int,double> b = {i, n, (double)(dist+1)};
edges.push_back(b);
} else {
int dist = n-i;
std::tuple<int,int,double> b = {i, n, ((double)dist)/(arr[i])};
edges.push_back(b);
}
}
auto [min,path] = shortestPathDirected(edges,start,goal);
println(min);
}
template<typename T>
std::vector<T> distanceTable(const std::vector<T> &init, const std::function<T(T,T)> &distance){
int n = init.size();
std::vector<T> table(n*n);
for (int i = 0; i < n; i++){
table[i+n*i] = init[i];
for (int j = i-1; j >= 0; j--){
table[j+n*i] = distance(init[j],table[j+1+n*i]);
}
for (int j = i+1; j < n; j++){
table[j+n*i] = distance(table[j-1+n*i],init[j]);
}
}
return table;
}
void particles(){
auto [n] = readInt1();
auto arr = readVecLong(n);
std::vector<long long> table = distanceTable(arr,add<long long>());
print(table,n);
//println(cost[n*n-1]);
}
template<typename T>
std::vector<T> range(const std::vector<T> &a, int from, int to){
std::vector<T> b;
for (int i = from; i <= to; i++){
b.push_back(a[i]);
}
return b;
}
void dynamicRangeMinimumQueries(){
auto [n,q] = readInt2();
auto arrv = readVecInt(n);
auto arrq = readVecTup3(q);
int n = 0;
//for (auto &q :arrq){
while (n < q){
n++;
auto q = readInt3();
if (std::get<0>(q)==1){
auto [t,k,u] = q;
arrv[k-1] = u;
}else{
auto [t,a,b] = q;
auto curmin = arrv[a-1];
for (int i = a-1; i <= b-1; i++){
curmin = std::min(curmin,arrv[i]);
}
println(curmin);
}
}
}
int main() {
//std::vector<std::vector<int>> a;
//for (int i = 0; i < 5; i++){
// std::vector<int> b = {1,2,3};
// a.push_back(b);
//}
//println(a,1);
//marioKart2();
//particles();
dynamicRangeMinimumQueries();
return 0;
}