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

using namespace std;

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

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

void Update(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(2*currentNod, beginInterval, middle, position, value) :
                         Update(2*currentNod+1, middle + 1, endInterval, position, value);

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

void BuildIntervalTree()
{
    int position;
    int value;

    in>> numberOfElements>> numberOfQueries;

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

void MaximumValueOfInterval(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(2*currentNod, beginInterval, middle,
                               beginQueryInterval, endQueryInterval, maximum);
    }

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

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

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

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

int main()
{
    BuildIntervalTree();

    ProcessQueries();

    return 0;
}