#include <fstream>
#include <vector>
#include <cmath>

using namespace std;

const int NMAX = 100000;

int v[NMAX];

vector<int> maxime;

/// asta e o solutie cu bucati de radical ce nu intra in timp oricum

int main()
{
    ifstream in("arbint.in");
    ofstream out("arbint.out");

    int n, m;
    in >> n >> m;

    for (int i = 0; i < n; i++)
        in >> v[i];

    int sqrtN = sqrt(n);

    for (int i = 0; i < n; i += sqrtN)
    {
        int maximCrt = 0;

        int capatDr = min(i + sqrtN, n);

        for (int j = i; j < capatDr; j++)
            maximCrt = max(maximCrt, v[j]);

        maxime.push_back(maximCrt);
    }

    for (int i = 0; i < m; i++)
    {
        int tipOperatie, a, b;
        in >> tipOperatie >> a >> b;

        a--;

        if (tipOperatie == 0)
        {
            b--;

            int indexSt = a / sqrtN;
            int indexDr = b / sqrtN;

            int sol = 0;

            if (indexSt < indexDr) /// nu mai merge daca a si b sunt in aceeasi bucata de radical
            {
                if (a % sqrtN != 0)
                {
                    int capatDr = min(n, a / sqrtN * sqrtN + sqrtN);

                    for (int j = a; j < capatDr; j++)
                        sol = max(sol, v[j]);

                    indexSt++;
                }

                if ((b + 1) % sqrtN != 0)
                {
                    int capatSt = b / sqrtN * sqrtN;

                    for (int j = capatSt; j <= b; j++)
                        sol = max(sol, v[j]);

                    indexDr--;
                }

                for (int j = indexSt; j <= indexDr; j++)
                    sol = max(sol, maxime[j]);
            }
            else
            {
                for (int j = a; j <= b; j++)
                    sol = max(sol, v[j]);
            }

            out << sol << '\n';
        }
        else
        {
            v[a] = b;

            int indexInterval = a / sqrtN;
            maxime[indexInterval] = 0;

            int capatSt = a / sqrtN * sqrtN;
            int capatDr = min(capatSt + sqrtN, n);

            for (int j = capatSt; j < capatDr; j++)
                maxime[indexInterval] = max(maxime[indexInterval], v[j]);
        }
    }

    return 0;
}