#include <fstream>
#include <algorithm>

using namespace std;

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

struct arbore
{
    int st, dr, val;
};

int n, m, k, i, t, x, y, max1, a[100005];
arbore arb[500005];

void maxim(const int& p, int &max1, const int& stg, const int& drp)
{
    if(p >= k || stg > drp)
        return;
    if(drp < arb[p].st || arb[p].dr < stg)
        return;
    if(stg <= arb[p].st && arb[p].dr <= drp)
        max1 = max(max1, arb[p].val);
    else
    {
        maxim(p * 2 + 1, max1, stg, arb[p * 2 + 1].dr);
        maxim(p * 2 + 2, max1, arb[p * 2 + 2].st, drp);
    }
}

void actualizeaza(const int& poz)
{
    int aux;

    aux = arb[poz].val;
    arb[poz].val = max(arb[poz * 2 + 1].val, arb[poz * 2 + 2].val);
    if(arb[poz].val != aux)
        actualizeaza((poz - 1) / 2);
}

int main()
{
    f >> n >> m;
    for(i = 0; i < n; i++)
        f >> a[i];

    k = 1;
    arb[0].st = 0;
    arb[0].dr = n - 1;
    for(i = 0; i < k; i++)
    {
        arb[i].val = -1;
        if(arb[i].st != -1 && arb[i].st == arb[i].dr)
        {
            arb[k].st = arb[k].dr = -1;
            k++;
            arb[k].st = arb[k].dr = -1;
            k++;
        }
        else
            if(arb[i].st != arb[i].dr)
            {
                arb[k].st = arb[i].st;
                arb[k].dr = (arb[i].st + arb[i].dr) / 2;
                k++;
                arb[k].st = arb[k - 1].dr + 1;
                arb[k].dr = arb[i].dr;
                k++;
            }
    }
    for(i = k - 1; i >= 0; i--)
        if(arb[i].st != -1)
            if(arb[i].st == arb[i].dr)
                arb[i].val = a[arb[i].st];
            else
                arb[i].val = max(arb[i].val, max(arb[i * 2 + 1].val, arb[i * 2 + 2].val));

    while(m)
    {
        f >> t >> x >> y;

        if(!t)
        {
            max1 = -1;
            maxim(0, max1, x - 1, y - 1);
            g << max1 << '\n';
        }
        else
            for(i = k - 1; i >= 0; i--)
                if(arb[i].st == arb[i].dr && arb[i].st == x - 1)
                {
                    arb[i].val = y;
                    actualizeaza((i - 1) / 2);
                    break;
                }

        m--;
    }

    f.close();
    g.close();

    return 0;
}