#include<bits/stdc++.h>
using namespace std;

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

#define INF 99999999

int n,query_count,values[100000],tree[200000];

void read()
{
    in>>n>>query_count;
    for(int i=0; i<n; i++)
    {
        in>>values[i];
    }
}



void build_tree(int left,int right,int index)
{
    if(left==right)
    {
        tree[index]=values[right];
    }
    else
    {
        int middle=(left+right)/2;

        build_tree(left,middle,index*2);
        build_tree(middle+1,right,index*2+1);

        tree[index]=max(tree[index*2],tree[index*2+1]);
    }
}


int query(int left,int right,int index,int a,int b)
{
    if(left>=a && right<=b)
    {
        return tree[index];
    }
    else
    {
        int middle=(left+right)/2;
        int result=-INF;
        if(a<=middle)
        {
            result=max(result,query(left,middle,index*2,a,b));
        }
        if(b>middle)
        {
            result=max(result,query(middle+1,right,index*2+1,a,b));
        }

        return result;
    }
}

void update(int left,int right,int index,int desired,int value)
{
    if(left==right)
    {
        tree[index]=value;
    }
    else
    {
        int middle=(left+right)/2;

        if(desired<=middle)
        {
            update(left,middle,index*2,desired,value);
        }
        else
        {
            update(middle+1,right,index*2+1,desired,value);
        }

        tree[index]=max(tree[index*2],tree[index*2+1]);
    }
}



void update_index(int index,int value)
{
    update(0,n-1,1,index,value);
}


void create_tree()
{
    build_tree(0,n-1,1);
}

int query_interval(int left,int right)
{
    return query(0,n-1,1,left,right);
}

void solve()
{
    int a,b,c;

    for(int i=0; i<query_count; i++)
    {
        in>>a>>b>>c;
        if(a==0)
        {
            out<<query_interval(b-1,c-1)<<'\n';
        }
        else
        {
            update_index(b-1,c);
        }
    }

}


int main()
{
    read();
    create_tree();
    solve();
    return 0;
}