//
//  Arbint.cpp
//  
//
//  Created by Raoul Bocancea on 21/11/2018.
//

#include <fstream>

const std :: string programName = "arbint";
std :: ifstream f(programName + ".in");
std :: ofstream g(programName + ".out");

const int MAX = 1E5, INF = 0x3f3f3f3f;

int v[MAX + 5], St[4 * MAX + 5];

void Build(int, int, int);
void query(int, int, int, int, int, int&);
void update(int, int, int, int, int);

int main(void) {
    int N, M;
    f >> N >> M;
    for (int i = 1; i <= N; ++i)
        f >> v[i];
    Build(1, 1, N);
    int quest;
    while (M--) {
        f >> quest;
        if (quest == 0) {
            int a, b;
            int answer = -INF;
            f >> a >> b;
            query(1, 1, N, a, b, answer);
            g << answer << '\n';
        }
        int value, position;
        if (quest == 1) {
            f >> position >> value;
            update(1, 1, N, position, value);
        }
    }
    return 0x0;
}

void Build(int node, int left, int right) {
    if (left == right)
        St[node] = v[left];
    else {
        int mid = (left + right) / 2, leftSon = 2 * node, rightSon = leftSon + 1;
        Build(leftSon, left, mid);
        Build(rightSon, mid + 1, right);
        St[node] = std::max(St[leftSon], St[rightSon]);
    }
}

void query(int node, int left, int right, int queryL, int queryR, int& max) {
    if (queryL <= left and right <= queryR)
        max = std :: max(max, St[node]);
    else {
        int mid = (left + right) / 2, leftSon = 2 * node, rightSon = leftSon + 1;
        if (queryL <= mid)
            query(leftSon, left, mid, queryL, queryR, max);
        if (queryR > mid)
            query(rightSon, mid + 1, right, queryL, queryR, max);
    }
}

void update(int node, int left, int right, int pos, int val) {
    if (left == right)
        St[node] = val;
    else {
        int mid = (left + right) / 2, leftSon = 2 * node, rightSon = leftSon + 1;
        if (pos <= mid)
            update(leftSon, left, mid, pos, val);
        else
            update(rightSon, mid + 1, right, pos, val);
        St[node] = std :: max(St[leftSon], St[rightSon]);
    }
}