/// O(M * sqrt(N))
/// puncte = 100, time = 0.440
#include <stdio.h>
#include <fstream>

using namespace std;

#define in "arbint.in"
#define out "arbint.out"
#define dim 100001
#define LG 319

inline int max(int a, int b) {
       if ( a > b ) return ( a );
                    return ( b );
}

inline int min(int a, int b){
    if (a < b) return ( a );
               return ( b );
}

int N, M, X, Y, tip, size, K;
int Arb[LG], A[dim];
int St[LG], Dr[LG];

void Update();
int Query();
int sqrt(int x);

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

int main()
{
    //freopen(in,"r",stdin);
    //freopen(out,"w",stdout);

    //scanf("%d%d", &N, &M);
    fin >> N >> M;
    for ( int i = 1; i <= N; i++ )
    {
        //scanf("%d", &A[i]);
        fin >> A[i];
        //printf("%d %d\n", i, A[i]);
    }

    size = sqrt( N ); //printf("%d\n", size);

    K = N/size + 1;

    for ( int i = 1; i <= K; ++i )
    {
        St[i] = Dr[i - 1] + 1, Dr[i] = size * i; Arb[i] = Dr[i];
        for ( int nod = St[i]; nod < Dr[i]; ++nod )
          if (A[nod] > A[Arb[i]]) Arb[i] = nod;
        //printf("%d %d %d\n", i, Arb[i], A[Arb[i]]);
    }

    for ( ; M; M-- )
    {
        fin >> tip >> X >> Y;
        //scanf("%d%d%d", &tip, &X, &Y);
        //printf("%d %d %d\n", tip, X, Y);

        if ( tip ) Update();
        else       fout << Query() << '\n';
    }
}

int sqrt(int x)
{
    int i, step;
    for (step = 1; step < x; step <<= 1);
    for (i = 0; step; step >>= 1)
       if ( (long long)(i + step) * (i + step) <= x)
       i += step;
    return ( i );
}

void Update()
{
     int i = X / size + (X % size != 0);
     if (Arb[i] == X)
     {
         if (A[Arb[i]] > Y) {
             A[X] = Y;
             Arb[i] = Dr[i];
             for ( int nod = St[i]; nod < Dr[i]; nod++ )
                  if (A[Arb[i]] < A[nod]) Arb[i] = nod;
         }
     }
     else {
         if (A[Arb[i]] < Y) Arb[i] = X;
     }

     A[X] = Y;
}

int Query()
{
    int maxim = -1;
    int st = X / size + 1 , dr = Y / size;

    for ( int i = st + (X % size > 1); i <= dr; ++i )
       if ( maxim < A[Arb[i]] ) maxim = A[Arb[i]];

    for ( int i = min(Y, Dr[st]); i >= X; --i )
       if (maxim < A[i]) maxim = A[i];

    for ( int i = max(Dr[dr], X); i <= Y; ++i )
       if (maxim < A[i]) maxim = A[i];

    return maxim;
}

/*
/// O(MlogN) - Arbori_de_Intervale
/// time = 0.192
#include <iostream>
#include <cstdio>

using namespace std;

#define in "arbint.in"
#define out "arbint.out"
#define dim 100001

int N, M;
int MaxArb[dim<<2];
int start, finish, Val, Pos, maxim;

inline int Maxim(int a, int b) {
       if ( a > b ) return a;
       return b;
}

void Update(int,int,int);
void Query(int,int,int);

int main()
{
    int X, A, B;
    freopen(in,"rt",stdin);
    freopen(out,"wt",stdout);

    scanf("%d%d", &N, &M);
    for ( int i = 1; i <= N; i++ )
    {
        scanf("%d", &X);
        Pos = i, Val = X;
        Update(1,1,N);
    }

    for ( int i = 1; i <= M; i++ )
    {
        scanf("%d%d%d", &X, &A, &B);
        if ( X == 0 )
        {
             maxim = -1;
             start = A, finish = B;
             Query(1,1,N);

             printf("%d\n", maxim);
        }
        else
        {
            Pos = A, Val = B;
            Update(1,1,N);
        }
    }

    fclose(stdin);
    fclose(stdout);
    return 0;
}

void Update(int nod, int left, int right)
{
     if ( left == right )
     {
          MaxArb[nod] = Val;
          return;
     }

     int div = (left+right)>>1;
     if ( Pos <= div ) Update(nod<<1,left,div);
     else              Update((nod<<1)+1,div+1,right);

     MaxArb[nod] = Maxim( MaxArb[2*nod], MaxArb[2*nod+1] );
}

void Query(int nod, int left, int right)
{
     if ( start <= left && right <= finish )
     {
          if ( maxim < MaxArb[nod] ) maxim = MaxArb[nod];
          return;
     }

     int div = (left+right)>>1;
     if ( start <= div ) Query(nod<<1,left,div);
     if ( div < finish ) Query((nod<<1)+1,div+1,right);
}
*/
/*
/// O(Mlog^2N) - Arbori_Indexati_Binar
/// TIME = 0.184
#include <stdio.h>

#define NX (1<<17)
#define INF (0x3f3f3f3f)

int T[ NX ], a[ NX ];
int N, M;

int que( int l, int r ) {
    int p, q, m = 0;

    for( p=r-(r&-r); l<=r; r=p, p-=p&-p ) {
        q = ( p+1 >= l ) ? T[r] : (p=r-1) + 1;
        if( a[m] < a[q] )
            m = q;
    }

    return m;
}

void upd( int x ) {
    int y, z;
    for( y = x; x <= N; x += x & -x )
        if( T[x] == y ) {
            z = que( x-(x&-x) + 1, x-1 );
            T[x] = (a[z] > a[x]) ? z : x;
        }
        else
            if( a[ T[x] ] < a[ y ] )
                T[x] = y;
}

int main() {
    int i, x, y, op;

    freopen( "arbint.in", "r", stdin );
    freopen( "arbint.out", "w", stdout );

    a[0] = -INF;
    scanf( "%d%d", &N, &M );

    for( i = 1; i <= N; i++ ) {
        scanf( "%d", a+i );
        upd( i );
    }

    while( M-- ) {
        scanf( "%d%d%d", &op, &x, &y );
        if( op == 0 )
            printf( "%d\n", a[ que( x, y ) ] );
        else
            a[x] = y, upd( x );
    }

    fclose(stdin);
    fclose(stdout);
    return 0;
}
*/