#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

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

int numberOfElements;
int numberOfQueries;
int beginQueryInterval;
int endQueryInterval;
int maximum;
int position;
int value;
vector<int> intervalTree(200500);

void Update(int currentNod, int beginInterval, int endInterval)
{
    if( beginInterval == endInterval )
    {
        intervalTree[currentNod] = value;
        return;
    }

    int middle = (beginInterval + endInterval) / 2;
    position <= middle ? Update(2*currentNod, beginInterval, middle) :
                         Update(2*currentNod+1, middle + 1, endInterval);

    intervalTree[currentNod] = max( intervalTree[2*currentNod], intervalTree[2*currentNod+1] );
}

void BuildIntervalTree()
{
    in>> numberOfElements>> numberOfQueries;

    for( int i = 1; i<=numberOfElements; ++i )
    {
        in>> value;
        position = i;
        Update(1, 1, numberOfElements);
    }
}

void MaximumValueOfInterval(int currentNod, int beginInterval, int endInterval)
{
    if( beginQueryInterval <= beginInterval && endQueryInterval >= endInterval )
    {
        if( maximum < intervalTree[currentNod] )
        {
            maximum = intervalTree[currentNod];
        }
        return;
    }
    else
    {
        int middle = (beginInterval + endInterval) / 2;
        if( beginQueryInterval <= middle)
        {
            MaximumValueOfInterval(2*currentNod, beginInterval, middle);
        }

        if( middle < endQueryInterval )
        {
            MaximumValueOfInterval(2*currentNod+1, middle + 1, endInterval);
        }
    }
}

void ProcessQueries()
{
    int queryType;
    int aux1;
    int aux2;

    while(numberOfQueries--)
    {
        in>> queryType>> aux1>> aux2;

        if( queryType == 0 )
        {
            maximum = -1;
            beginQueryInterval = aux1;
            endQueryInterval = aux2;
            MaximumValueOfInterval(1, 1, numberOfElements);
            out<< maximum<< endl;
        }
        else
        {
            position = aux1;
            value = aux2;
            Update(1, 1, numberOfElements);
        }
    }
}

int main()
{
    BuildIntervalTree();
    ProcessQueries();

    in.close();
    out.close();
    return 0;
}