#include <iostream>
#include <fstream>

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;
    }

     // Traversează subarborele stâng
    cout << "Interval: [" << radacina->ls << ", " << radacina->ld << "] "<<radacina->maxi << endl;
    afisare(radacina->stanga);
    afisare(radacina->dreapta); // Traversează subarborele drept
}

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;
}