/*
Arbori de intervale
Fie un vector A cu N elemente naturale. Asupra lui se vor face M operatii, codificate astfel in fisierul de intrare:
• 0 a b - Sa se determine maximul din intervalul [a,b] (maximul dintre valorile Ai cu a ≤ i ≤ b).
• 1 a b - Valoarea elementului de pe pozita a va deveni b.

Date de intrare
Pe prima linie a fisierului de intrare se afla N si M. Pe urmatoarea linie se gasesc cele N elemente ale vectorului, iar urmatoarele M linii descriu operatia care trebuie efectuata.

Date de iesire
Pentru fiecare operatie de tip 0, se va afisa pe cate o linie maximul pentru intervalul cerut (in ordinea ceruta in fisierul de intrare).

Restrictii
1 ≤ M, N ≤ 100000
0 ≤ Ai ≤ 109 pentru 1 ≤ i ≤ N
Pentru operatia de tip 0: 1 ≤ a ≤ b ≤ N 
Pentru operatia de tip 1: 1 ≤ a ≤ N si 1 ≤ b ≤ 109 
*/
#include <bits/stdc++.h>
#define NMAX 100005
#define MAXX 200005

using namespace std;

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

int v[NMAX], a[MAXX];

void construieste ( int nod, int st, int dr );
int query ( int nod, int st, int dr, int x, int y );
void update ( int nod, int st, int dr, int poz, int val );

int main()
{
    int n, q, i, x, y, z;

    fin >> n >> q;
    for ( i = 1; i <= n; i++ ) fin >> v[i];
    construieste ( 1, 1, n );

    while ( q-- )
    {
        fin >> x >> y >> z;
        if ( x == 0 ) fout << query ( 1, 1, n, y, z ) << '\n';
        else update ( 1, 1, n, y, z );
    }

    return 0;
}

void construieste ( int nod, int st, int dr )
{
    int mij;

    if ( st == dr ) a[nod] = v[st];
    else
    {
        mij = ( st + dr ) / 2;
        construieste ( 2 * nod, st, mij );
        construieste ( 2 * nod + 1, mij + 1, dr );
        a[nod] = max ( a[2*nod], a[2*nod+1] );
    }
}

void update ( int nod, int st, int dr, int poz, int val )
{
    int mij;

    if ( st == dr ) a[nod] = val;
    else
    {
        mij = ( st + dr ) / 2;
        if ( poz <= mij ) update ( 2 * nod, st, mij, poz, val );
        else update ( 2 * nod + 1, mij + 1, dr, poz, val );
        a[nod] = max ( a[2*nod], a[2*nod+1] );
    }
}

int query ( int nod, int st, int dr, int x, int y )
{
    int mij;

    if ( x <= st && y >= dr ) return a[nod];
    else
    {
        mij = ( st + dr ) / 2;
        if ( x > mij ) return query ( 2 * nod + 1, mij + 1, dr, x, y );
        else if ( y <= mij ) return query ( 2 * nod, st, mij, x, y );
        else return max ( query ( 2 * nod + 1, mij + 1, dr, x, y ), query ( 2 * nod, st, mij, x, y ) );
    }
}

/*
IN:
5 5
4 3 5 6 1
0 1 3
1 3 2
0 2 3
1 4 2
0 1 5

OUT:
5
3
4
*/