#include <iostream>
#include <fstream>
#include <algorithm>
#include <climits>

using namespace std;

ifstream fin("arbint.in");
ofstream fout("arbint.out");

int n, m, A[100001];

struct nod {
    int ls, ld, maxi;
    nod* stanga;
    nod* dreapta;

    nod(int lis, int lid) : ls(lis), ld(lid), stanga(nullptr), dreapta(nullptr) {}
};

nod* create(int lis, int lid) {
    int maxim = A[lis];
    for (int i = lis; i <= lid; i++)
        maxim = max(maxim, A[i]);

    int mij = (lis + lid) / 2;
    nod* c = new nod(lis, lid);
    c->maxi = maxim;

    if (lis != lid) {
        c->stanga = create(lis, mij);
        c->dreapta = create(mij + 1, lid);
    }

    return c;
}

void afisare(nod* radacina) {
    if (radacina == nullptr) {
        return;
    }

    cout << "Interval: [" << radacina->ls << ", " << radacina->ld << "] " << radacina->maxi << endl;
    afisare(radacina->stanga);
    afisare(radacina->dreapta);
}

int cautareInterval(nod* radacina, int st, int dr) {
    if (radacina == nullptr) {
        return INT_MIN; // Dacă arborele este gol, returnăm minimul posibil
    }

    if (radacina->ls == st && radacina->ld == dr) {
        return radacina->maxi; // Intervalul este exact egal, returnăm maximul nodului curent
    }

    int mij = (radacina->ls + radacina->ld) / 2;
    int maximStanga = INT_MIN, maximDreapta = INT_MIN;

    if (st <= mij) {
        maximStanga = cautareInterval(radacina->stanga, st, min(dr, mij));
    }

    if (dr > mij) {
        maximDreapta = cautareInterval(radacina->dreapta, max(st, mij + 1), dr);
    }

    return max(maximStanga, maximDreapta); // Returnăm maximul dintre subintervale
}

void actualizeaza(nod* radacina, int index, int valoare) {
    if (radacina == nullptr) {
        return;
    }

    if (radacina->ls == radacina->ld && radacina->ls == index) {
        radacina->maxi = valoare;
        return;
    }

    int mij = (radacina->ls + radacina->ld) / 2;
    if (index <= mij) {
        actualizeaza(radacina->stanga, index, valoare);
    } else {
        actualizeaza(radacina->dreapta, index, valoare);
    }

    radacina->maxi = max(
        (radacina->stanga ? radacina->stanga->maxi : INT_MIN),
        (radacina->dreapta ? radacina->dreapta->maxi : INT_MIN)
    );
}

int main() {
    int i, op, ls, ld;
    fin >> n >> m;
    for (i = 1; i <= n; i++) {
        fin >> A[i];
    }

    nod* radacina = create(1, n);
    // Afișează arborele
    // afisare(radacina);

    for (i = 1; i <= m; i++) {
        fin >> op >> ls >> ld;
        if (op == 0) {
            fout << cautareInterval(radacina, ls, ld) << "\n";
        } else {
            A[ls] = ld;
            actualizeaza(radacina, ls, ld);
        }
    }
    // afisare(radacina);

    return 0;
}