#include <iostream>
#include <fstream>

using namespace std;

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

struct Nod
{
    int x, st, dr, t, a, b;
    bool info;
};

int n, m, node_val, V[100001], I[100001];
Nod A[200001];

/*
void Constr(int a, int b, int ind)
{
    if (a == b)
    {
        A[ind].x = V[a];
        A[ind].st = A[ind].dr = 0;
        A[ind].a = A[ind].b = a;
        I[a] = ind;
    }
    else
    {
        A[++cnt].t = ind;
        A[cnt].info = false;
        A[ind].st = cnt;
        Constr(a, (a + b) / 2, cnt);
        A[ind].a = A[A[ind].st].a;

        A[++cnt].t = ind;
        A[cnt].info = true;
        A[ind].dr = cnt;
        Constr((a + b) / 2 + 1, b, cnt);
        A[ind].x = max(A[A[ind].st].x, A[A[ind].dr].x);
        A[ind].b = A[A[ind].dr].b;
    }
}
*/

void ConstructTree(int node, int a, int b)
{
    A[node].a = a;
    A[node].b = b;

    if (a == b)
    {
        I[a]       = node;
        A[node].x = V[a];
    }
    else
    {
        const int mid = (a + b) / 2;

        A[node].st     = ++node_val;
        A[node_val].t = node;
        ConstructTree(node_val, a, mid);

        A[node].dr     = ++node_val;
        A[node_val].t = node;
        ConstructTree(node_val, mid + 1, b);

        A[node].x = max(A[A[node].st].x, A[A[node].dr].x);
    }
}

void GetMax(int &a, int &b, int nod, int& ma)
{
    // cout << A[nod].a << " " << A[nod].b << '\n';
    if (A[nod].a >= a && A[nod].b <= b)
        ma = max(ma, A[nod].x);
    if (A[nod].b < b)
    {
        if (A[A[nod].dr].a >= a)
            ma = max(ma, A[A[nod].dr].x);
        GetMax(a, b, A[nod].t, ma);
    }
    if (A[nod].b >= b)
    {
        if (A[nod].a >= a && A[nod].b == b)
            return;
        if (A[A[nod].st].b >= b)
        {
            GetMax(a, b, A[nod].st, ma);
        }
        else
        {
            if (A[nod].a == 1 && A[nod].b == 5)
                cout << A[6].a << " " << A[6].b << "DA";
            if (A[A[nod].st].a >= a)
                ma = max(ma, A[A[nod].st].x);
            GetMax(a, b, A[nod].dr, ma);
        }
    }
}

void Afis(int nod)
{
    if (nod == 0)
        return;
    cout << A[nod].a << " " << A[nod].b << '\n';
    Afis(A[nod].st);
    cout << "|";
    Afis(A[nod].dr);
    cout << "-";
}

void UpdateMax(int nod)
{
    if (nod == 0)
        return;
    if (max(A[A[nod].st].x, A[A[nod].dr].x) != A[nod].x)
    {
        A[nod].x = max(A[A[nod].st].x, A[A[nod].dr].x);
        UpdateMax(A[nod].t);
    }
}

int main()
{
    fin >> n >> m;
    for (int i = 1; i <= n; ++i)
        fin >> V[i];
    ConstructTree(++node_val, 1, n);
    for (int i = 1; i <= m; ++i)
    {
        int c, a, b;
        fin >> c >> a >> b;
        if (c == 0)
        {
            int ma = 0;
            //Afis(1);
            GetMax(a, b, I[a], ma);
            fout << ma << '\n';
        }
        else
        {
            A[I[a]].x = b;
            UpdateMax(A[I[a]].t);
        }
    }

    return 0;
}