#include <iostream>
#include <fstream>
#include <algorithm>
#define NMax 270006
using namespace std;

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

int n, m, a[NMax];

int Query (int NodCurent, int x, int y, int stanga, int dreapta){
    if (x == stanga && y == dreapta){
        return a[NodCurent];
    }

    int mid = (stanga + dreapta) / 2;
    if (y <= mid){
        return Query(2 * NodCurent, x , y, stanga, mid);
    }

    if (x >= mid + 1){
        return Query(2 * NodCurent + 1, x, y, mid + 1, dreapta);
    }

    return max (Query(2 * NodCurent, x, mid, stanga, mid), Query(2 * NodCurent + 1, mid + 1, y, mid + 1, dreapta));
}

void Update (int pozitie, int valoare){
    pozitie += n - 1;
    a[pozitie] = valoare;
    int aladedeasupra = 0;
    while (pozitie != 0){
        aladedeasupra = pozitie / 2;
        a[aladedeasupra] = max (a[2 * aladedeasupra], a[2 * aladedeasupra + 1]);
        pozitie = aladedeasupra;
    }
}

void Read (){
    int x, y, opt, valoareaux, valoarepentrultimulnivel = 1, indiceultimulnivel;

    fin >> n >> m;

    ///vedem de la ce pozitite vor veni valorile de pe ultimul nivel
    while (valoarepentrultimulnivel <= n)
        valoarepentrultimulnivel *= 2;

    indiceultimulnivel = valoarepentrultimulnivel;

    ///citim oleaca valorile si le siftam pe ultimul nivel
    for (int i = 1; i <= n; i++){
        fin >> valoareaux;
        a[indiceultimulnivel++] = valoareaux;
    }

    n = valoarepentrultimulnivel;

    ///acuma formam si restul nivelurilor
    for (int i = n - 1; i >= 1; i--){
        a[i] = max (a[2 * i], a[2 * i + 1]);
    }

    ///hai sa-i dam si cu interogarile

    for (int i = 1; i <= m; i++){
        fin >> opt >> x >> y;

        if (opt == 0) {
            fout << Query(1, x, y, 1, n) << " ";
        }
        else {
            Update(x, y);
        }
    }
}

int main (){
    Read();
    return 0;
}