#include <iostream>
#include <fstream>
using namespace std;

ifstream f("arbint.in");
ofstream g("arbint.out");

int n, m;
int v[100005];

int segment_tree[400005];

int build(int node, int s, int d){

    if(s > d){

        segment_tree[node] = -1;
    }
    if(s == d){

        segment_tree[node] = v[s];
    }
    else if(s < d){

        segment_tree[node] = max(build(node * 2, s, (s + d) / 2), build(node * 2 + 1, (s + d) / 2 + 1, d));
    }

    return segment_tree[node];
}

int get_max(int node, int node_s, int node_d, int s, int d){

    if(node_s > node_d || d < node_s || node_d < s){

        return -1;
    }
    else if(s <= node_s && node_d <= d){

        return segment_tree[node];
    }
    else{

        return max(get_max(node * 2, node_s, (node_s + node_d) / 2, s, d), get_max(node * 2 + 1, (node_s + node_d) / 2 + 1, node_d, s, d));
    }
}

void update(int node, int node_s, int node_d, int x, int to_replace){

    if(node_s > node_d || x < node_s || node_d < x){

        return;
    }
    else if(node_s == x && node_s == node_d){

        segment_tree[node] = to_replace;
    }
    else{

        update(node * 2, node_s, (node_s + node_d) / 2, x, to_replace);
        update(node * 2 + 1, (node_s + node_d) / 2 + 1, node_d, x, to_replace);

        segment_tree[node] = max(segment_tree[node * 2], segment_tree[node * 2 + 1]);
    }
}

int main(){

    f>>n>>m;

    for(int i = 0; i < n; i++){

        f>>v[i];
    }

    for(int i = 0; i < 4 * n + 1; i++){

        segment_tree[i] = -1;
    }

    build(1, 0, n - 1);

    int q, a, b, x;

    for(int i = 0; i < m; i++){

        f>>q;

        if(q == 0){

            f>>a>>b;

            a -= 1;
            b -= 1;

            g<<get_max(1, 0, n - 1, a, b)<<'\n';
        }
        else{

            f>>a>>b;

            a -= 1;

            update(1, 0, n - 1, a, b);
        }
    }
    return 0;
}