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

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

int intervalTree[MAX*2-1];

void Build_Interval_Tree(int st, int dr, int position, vector<int>values);

int Find_Maximum_Value(int leftLimit, int rightLimit, int nodePosition, int st, int dr);
int Update_Interval_Tree(int position, int value, int st, int dr, int nodePosition);

int main()
{
    int nrOfElements, nrOfQuerries;
    vector<int>values;

    fin >> nrOfElements >> nrOfQuerries;

    for(int i = 0; i < nrOfElements; i++)
    {
       int value;
       fin>>value;

       values.push_back(value);
    }

    Build_Interval_Tree(0, nrOfElements-1, 0, values);

    for(int i = 0; i < nrOfQuerries; i++)
    {
        bool questionType;
        fin >> questionType;

        if(questionType == 0)
        {
            int leftLimit, rightLimit;
            fin >> leftLimit >> rightLimit;

            fout << Find_Maximum_Value(leftLimit-1, rightLimit-1, 0, 0, nrOfElements-1);
        }
        else
        {
            int position, value;
            fin >> position >> value;

            position--;

            values[position] = value;
            Update_Interval_Tree(position, value, 0, nrOfElements-1, 0);
        }
    }
}
int Update_Interval_Tree(int position, int value, int st, int dr, int nodePosition)
{
    if(st==dr)
    {
        intervalTree[nodePosition] = value;
        return value;
    }

    int mij = (st+dr)/2;

    int leftNodeValue = intervalTree[nodePosition*2+1];
    int rightNodeValue = intervalTree[nodePosition*2+2];

    if(position<=mij)
    {
        leftNodeValue = Update_Interval_Tree(position, value, st, mij, nodePosition*2+1);
    }
    else
    {
        rightNodeValue = Update_Interval_Tree(position, value, mij+1, dr, nodePosition*2+2);
    }

    intervalTree[nodePosition] = max(leftNodeValue,rightNodeValue);
}

int Find_Maximum_Value(int leftLimit, int rightLimit, int nodePosition, int st, int dr)
{
    if(st==dr)
    {
        return intervalTree[nodePosition];
    }

    int mij = (st+dr)/2;

    int leftNodeValue = 0;
    int rightNodeValue = 0;

    if(leftLimit <= mij)
    {
        leftNodeValue = Find_Maximum_Value(leftLimit, rightLimit, nodePosition*2+1, st, mij);
    }
    if(rightLimit > mij)
    {
        rightNodeValue = Find_Maximum_Value(leftLimit, rightLimit, nodePosition*2+2, mij+1, dr);
    }

    return max(leftNodeValue, rightNodeValue);
}

void Build_Interval_Tree(int st, int dr, int position, vector<int> values)
{
    if(st==dr)
    {
        intervalTree[position] =  values[st];
        return;
    }

    int mij = (st+dr)/2;

    /* build left */
    int leftNode = position*2+1;
    Build_Interval_Tree(st, mij, leftNode, values);

    /*build right*/
    int rightNode = position*2+2;
    Build_Interval_Tree(mij+1, dr, rightNode, values);

    intervalTree[position] = max(intervalTree[leftNode],intervalTree[rightNode]);
}