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

using namespace std;

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

void Update(vector<int> &intervalTree, int currentNod, int beginInterval, int endInterval,
            int position, int value)
{
    if( beginInterval == endInterval )
    {
        intervalTree[currentNod] = value;
        return;
    }

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

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

void BuildIntervalTree(vector<int> &intervalTree, int &numberOfElements, int &numberOfQueries)
{
    int position;
    int value;

    in>> numberOfElements>> numberOfQueries;

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

void MaximumValueOfInterval(vector<int> intervalTree, int currentNod, int beginInterval, int endInterval,
        int beginQueryInterval, int endQueryInterval, int &maximum)
{
    if( beginQueryInterval <= beginInterval && endQueryInterval >= endInterval )
    {
        maximum = max(maximum, intervalTree[currentNod]);
        return;
    }

    int middle = (beginInterval + endInterval) / 2;
    if( beginQueryInterval <= middle)
    {
        MaximumValueOfInterval(intervalTree, 2*currentNod, beginInterval, middle,
                               beginQueryInterval, endQueryInterval, maximum);
    }

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

void ProcessQueries(vector<int> intervalTree, int numberOfElements, int  numberOfQueries)
{
    int queryType;
    int aux1;
    int aux2;

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

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

int main()
{
    int numberOfElements;
    int numberOfQueries;
    vector<int> intervalTree(400500);

    BuildIntervalTree(intervalTree, numberOfElements, numberOfQueries);

    ProcessQueries(intervalTree, numberOfElements, numberOfQueries);

    return 0;
}