#include<bits/stdc++.h>
#define in f
#define out g
using namespace std;

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

int const MAXSIZE = 10000010;

struct tree {
    int l;
    int r;
    int maxx;
};

int viz[MAXSIZE];
int n, m, code, a, b, x, k;
queue<tree> q;
vector<tree> arb;

int build (int l, int r) {
    tree e;
    e.l = l;
    e.r = r;
    e.maxx = 0;
    q.push(e);
    arb.push_back(e);
    while (!q.empty()) {
        l = q.front().l;
        r = q.front().r;
        q.pop();
        if (l < r) {
            int mid = (l + r) / 2;
            tree t;
            t.l = l;
            t.r = mid;
            t.maxx = 0;
            q.push(t);
            arb.push_back(t);
            tree j;
            j.l = mid + 1;
            j.r = r;
            j.maxx = 0;
            q.push(j);
            //out << l << "  " << mid << endl;
            //out << mid + 1 << "  " << r << endl;
            arb.push_back(j);
        }
        if (l == r && viz[l] == 0) {
            tree s;
            s.l = l;
            s.r = r;
            s.maxx = 0;
            q.push(s);
            viz[l]++;
        }
    }
}

int insertion(int val, int node, int pos) {
    if (node < arb.size()) {
        arb[node].maxx = max(arb[node].maxx, val);
        int mid = (arb[node].l + arb[node].r) / 2;
        //out << node << "-> " << arb[node].maxx << endl;
        if (pos > mid)
            insertion(val, node * 2 + 1, pos);
        if (pos <= mid)
            insertion(val, node * 2, pos);
    }
}

int interval(int a, int b, int node) {
    //out << node << endl;
    //out << node << " -> " << k << endl;
    if (node < arb.size()) {
        if (a <= arb[node].l && b >= arb[node].r)
            k = max(k, arb[node].maxx);
        int mid = (arb[node].l + arb[node].r) / 2;
        if (a <= mid)
            interval(a, b, node * 2);
        if (b > mid)
            interval(a, b, node * 2 + 1);
    }
}

int up (int node) {
    if (node > 0) {
        arb[node].maxx = max (arb[node * 2].maxx, arb[node * 2 + 1].maxx);
        up(node / 2);
    }
}

int change(int a, int b, int node) {
    if (a == arb[node].l && arb[node].r == a) {
        arb[node].maxx = b;
        up(node / 2);
    } else {
        int mid = (arb[node].l + arb[node].r) / 2;
     //   out << a << " " << mid << "-> " << node << endl;
        if (a <= mid)
            change(a, b, node * 2);
        if (a > mid)
            change(a, b, node * 2 + 1);
    }

}

int main() {
    tree e;
    arb.push_back(e);
    in >> n >> m;
    build(1, n);
    for (int i = 1; i <= n; i++) {
        in >> x;
        insertion(x, 1, i);
    }
    for (int i = 1; i <= m; i++) {
        in >> code >> a >> b;
        if (code == 0) {
            k = 0;
            interval(a, b, 1);
            out << k << endl;
        } else {
            change(a, b, 1);
        }
    }
    return 0;
}