#include<bits/stdc++.h>
using namespace std;
void AINT(int node, int left, int right, vector<int> &a, vector<int> &segment_tree){
    if(left == right){
        segment_tree[node] = a[left];
    }
    else{
        int mid = (left + right) / 2;
        AINT(2 * node, left, mid, a, segment_tree);
        AINT(2 * node + 1, mid + 1, right, a, segment_tree);
        segment_tree[node] = max(segment_tree[2 * node], segment_tree[2 * node + 1]);
    }
}
int parcurgere(int node, int left, int right, int left_cautare, int right_cautare, vector<int> &segment_tree){
    if(left == left_cautare && right == right_cautare){
        return segment_tree[node];
    }
    int mid = (left + right) / 2;
    if(mid + 1 <= left_cautare){
       return parcurgere(2 * node + 1, mid + 1, right, left_cautare, right_cautare, segment_tree);
    }
    else{
        if(mid + 1 > right_cautare){
            return parcurgere(2 * node, left, mid, left_cautare, right_cautare, segment_tree);
        }
        else{
            return max(parcurgere(2 * node, left, mid, left_cautare, mid, segment_tree), parcurgere(2 * node + 1, mid + 1, right, mid + 1, right_cautare, segment_tree));
        }
    }
}
void finding(int node, vector<int> &segment_tree){
    if(segment_tree[node] == max(segment_tree[2 * node], segment_tree[2 * node + 1])){
        return;
    }
    else{
        segment_tree[node] = max(segment_tree[2 * node], segment_tree[2 * node]);
        if(node == 1){
            return;
        }
        else{
            finding(node / 2, segment_tree);
        }
    }
}
void update(int node, int left, int right, int pos, int val, vector<int> &segment_tree){
    if(left == pos && right == pos){
        segment_tree[node] = val;
        finding(node, segment_tree);
    }
    else{
        int mid = (left + right) / 2;
        if(mid + 1 <= pos){
            update(2 * node + 1, mid + 1, right, pos, val, segment_tree);
        }
        else{
            update(2 * node, left, mid, pos, val, segment_tree);
        }
    }
}
int main(){
    cin.tie(nullptr)->sync_with_stdio(false);
    int n, m;
    cin >> n >> m;
    vector<int> a(n + 1);
    for(int i = 1; i <= n; i++){
        cin >> a[i];
    }
    vector<int> segment_tree(4 * n + 5, -1);
    AINT(1, 1, n, a, segment_tree);
    //pana aici a fost creat arborele de intervale
    for(int i = 0; i < m; i++){
        int value, left, right;
        cin >> value >> left >> right;
        if(value == 0){
            cout << parcurgere(1, 1, n, left, right, segment_tree) << '\n';
        }
        else{
            update(1, 1, n, left, right, segment_tree);
        }
    }
    return 0;
}