///build: O(N*logN)
///update: O(logN)
///query: O(logN)
///Author: Lup Vasile PS: cel mai cool prof :sunglasses:
#include <bits/stdc++.h>
#define nmax 100010

using namespace std;

ifstream fin("arbint.in");
ofstream fout("arbint.out");
int aint[4*nmax],n,m;

void build(int,int,int);
void update(int,int,int,int,int);
int query(int,int,int,int,int);

int main()
{
    fin>>n>>m;

    build(1,1,n);

    int i,a,b,tip;

    for(i=1;i<=m;++i)
    {
        fin>>tip>>a>>b;

        if(tip==0) fout<<query(1,1,n,a,b)<<'\n';
        if(tip==1) update(1,1,n,a,b);
    }

    return 0;
}

/**
functia build() citeste din fisier sirul initial si construieste
direct arborele de intervale ; e echivalenta codului:
for(int i=1;i<=n;++i)
{
    int x;
    fin>>x;
    update(1,1,n,i,x);
}, dar acest cod e mai lent decat functia build

nod- indicele nodului din arbore
st- indicele capatului stang secventei din sir acoperita de nodul nod
dr- indicele capatului drept secventei din sir acoperita de nodul nod
**/
void build(int nod,int st,int dr)
{
    if(st==dr)///sunt in frunza
    {
        fin>>aint[nod];
        return;
    }

    int left=nod<<1;///fiul stang (nod*2)
    int right=nod<<1|1;///fiul stang (nod*2+1)
    int mid=(st+dr)>>1;///mijlocul intervalului (st+dr)/2

    build(left,st,mid);
    build(right,mid+1,dr);

    aint[nod]=max(aint[left],aint[right]);
    /**
        maximul din secventa din sir [st,dr] e maximul
        din intervalul [st,mid] si [mid+1,dr]
    **/
}

void update(int nod,int st,int dr,int pos,int val)
/**
    pos- pozitia din sir pe care facem update
    val- noua valoare
**/
{
    if(st==dr)///am ajuns in frunza, sigur pos==st==dr
    {
        aint[nod]=val;
        return;
    }

    int left=nod<<1,right=nod<<1|1,mid=(st+dr)>>1;

    if(pos<=mid)
        update(left,st,mid,pos,val);///pozitia pe care o cautam e in fiul stang
    else
        update(right,mid+1,dr,pos,val);///pozitia pe care o cautam e in fiul drept

    aint[nod]=max(aint[left],aint[right]);
}

int query(int nod,int st,int dr,int x,int y)
///x- indicele capatului stang secventei din sir de query
///y- indicele capatului drept secventei din sir de query
{
    if(x<=st && dr<=y) return aint[nod];
    ///subsecventa cautata contine indervalul aferent nodului nod
    int left=nod<<1,right=nod<<1|1,mid=(st+dr)>>1;

    if(y<=mid)
        return query(left,st,mid,x,y);
            ///intervalul cautat se afla in totalitate in fiul stang
    else if(x>mid)
        return query(right,mid+1,dr,x,y);
            ///intervalul cautat se afla in totalitate in fiul drept
        else
            return max(query(left,st,mid,x,y),query(right,mid+1,dr,x,y));
                ///o parte din interval e in fiul stang si o parte in fiul drept
}