#include <bits/stdc++.h>

using namespace std;

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

int v[500005], n, m;

class ArbInt
{
private:
    int aint[500007];

public:
    void BuildForMaxim(int nod, int st, int dr)
    {
        if(st == dr)
        {
            aint[nod] = v[st];
            return;
        }
        int mij = (st + dr) / 2;
        BuildForMaxim(2 * nod,  st, mij);
        BuildForMaxim(2 * nod + 1, mij + 1, dr);
        aint[nod] = max(aint[2 * nod], aint[2 * nod + 1]);
    }

    void BuildForMinim(int nod, int st, int dr)
    {
        if(st == dr)
        {
            aint[nod] = v[st];
            return;
        }
        int mij = (st + dr) / 2;
        BuildForMinim(2 * nod, st, mij);
        BuildForMinim(2 * nod + 1, mij + 1, dr);
        aint[nod] = min(aint[2 * nod], aint[2 * nod + 1]);
    }

    void BuildForSum(int nod, int st, int dr)
    {
        if(st == dr)
        {
            aint[nod] = v[st];
            return;
        }
        int mij = (st + dr) / 2;
        BuildForSum(2 * nod, st, mij);
        BuildForSum(2 * nod + 1, mij + 1, dr);
        aint[nod] = aint[2 * nod] + aint[2 * nod + 1];
    }

    void UpdateForMaxim(int nod, int st, int dr, int p, int x)
    {
        if(st == dr)
        {
            aint[nod] = x;
            return;
        }
        int mij = (st + dr) / 2;
        if(p <= mij)
            UpdateForMaxim(2 * nod, st, mij, p, x);
        else UpdateForMaxim(2 * nod + 1, mij + 1, dr, p, x);
        aint[nod] = max(aint[2 * nod], aint[2 * nod + 1]);
    }

    void UpdateForSum(int nod, int st, int dr, int p, int x)
    {
        if(st == dr)
        {
            aint[nod] = x;
            return;
        }
        int mij = (st + dr) / 2;
        if(p <= mij)
            UpdateForSum(2 * nod, st, mij, p, x);
        else UpdateForSum(2 * nod + 1, mij + 1, dr, p, x);
        aint[nod] = aint[2 * nod] + aint[2 * nod + 1];
    }

    void UpdateForMinim(int nod, int st, int dr, int p, int x)
    {
        if(st == dr)
        {
            aint[nod] = x;
            return;
        }
        int mij = (st + dr) / 2;
        if(p <= mij)
            UpdateForMinim(2 * nod, st, mij, p, x);
        else UpdateForMinim(2 * nod + 1, mij + 1, dr, p, x);
        aint[nod] = min(aint[2 * nod], aint[2 * nod + 1]);
    }

    int Maxim(int p, int left, int right, int st, int dr)
    {
        if(left == st && right == dr)
            return aint[p];
        int mij = (st + dr) / 2;
        if(mij >= right)
            return Maxim(2 * p, left, right, st, mij);
        if(mij + 1 <= left)
            return Maxim(2 * p + 1, left, right, mij + 1, dr);

        return max(Maxim(2 * p, left, mij, st, mij),
                   Maxim(2 * p + 1, mij + 1, right, mij + 1, dr));
    }

    int Sum(int p, int left, int right, int st, int dr)
    {
        if(left == st && right == dr)
            return aint[p];
        int mij = (st + dr) / 2;
        if(mij >= right)
            return Sum(2 * p, left, right, st, mij);
        if(mij <= left - 1)
            return Sum(2 * p + 1, left, right, mij + 1, dr);

        return Sum(2 * p, left, mij, st, mij) +
            Sum(2 * p + 1, mij + 1, right, mij + 1, dr);
    }

    int Minim(int p, int left, int right, int st, int dr)
    {
        if(left == st && right == dr)
            return aint[p];
        int mij = (st + dr) / 2;
        if(mij >= right)
            return Minim(2 * p, left, right, st, mij);
        if(mij < left)
            return Minim(2 * p + 1, left, right, mij + 1, dr);

        return min(Minim(2 * p, left, mij, st, mij),
                   Minim(2 * p + 1, mij + 1, right, mij + 1, dr));
    }
};

void SolveMax()
{
    ArbInt a;
    int i, task, x, y;
    a.BuildForMaxim(1, 1, n);
    for(i = 1; i <= m; i++)
    {
        fin >> task >> x >> y;
        if(task == 0)
            fout << a.Maxim(1, x, y, 1, n) << "\n";
        else
            a.UpdateForMaxim(1, 1, n, x, y);
    }
}

void SolveMin()
{
    ArbInt a;
    int i, task, x, y;
    a.BuildForMinim(1, 1, n);
    for(int i = 1; i <= m; i++)
    {
        fin >> task >> x >> y;
        if(task == 0)
            fout << a.Minim(1, x, y, 1, n) << "\n";
        else
            a.UpdateForMinim(1, 1, n, x, y);
    }
}

void SolveSum()
{
    ArbInt a;
    int i, task, x, y;
    a.BuildForSum(1, 1, n);
    for(int i = 1; i <= m; i++)
    {
        fin >> task >> x >> y;
        if(task == 0)
            fout << a.Sum(1, x, y, 1, n);
        else
            a.UpdateForSum(1, 1, n, x, y);
    }
}

int main()
{
    fin >> n >> m;
    for(int i = 1; i <= n; i++)
        fin >> v[i];
    SolveMax();

    return 0;
}