#include <iostream>
#include <vector>
#include <fstream>
#include <algorithm>

void build(std::vector<int>& arb, std::vector<int>& v, int index, int left, int right) {

    if (left == right) {
        arb[index] = v[left];
        return;
    }

    int mid = (left + right) / 2;
    build(arb, v, index * 2, left, mid);
    build(arb, v, index * 2 + 1, mid + 1, right);
    
    arb[index] = std::max(arb[index * 2], arb[index * 2 + 1]);
}

int maxim(std::vector<int>& arb, int index, int int_left, int int_right, int a, int b) {
    if (a == int_left && b == int_right) {
        return arb[index];
    }

    int mid = (int_left + int_right) / 2;
    if (b <= mid)
        return maxim(arb, 2 * index, int_left, mid, a, b);
    else if (a > mid)
        return maxim(arb, 2 * index + 1, mid + 1, int_right, a, b);
    
    return std::max(maxim(arb, 2 * index, int_left, mid, a, mid), maxim(arb, 2 * index + 1, mid + 1, int_right, mid + 1, b));
}

void update(std::vector<int>& arb, int current_index, int index, int val, int int_left, int int_right) {
    if (int_left == int_right) {
        arb[current_index] = val;
        return;
    }

    int mid = (int_left + int_right) / 2;
    if (index <= mid)
        update(arb, 2 * current_index, index, val, int_left, mid);
    else
        update(arb, 2 * current_index + 1, index, val, mid + 1, int_right);

    arb[current_index] = std::max(arb[2 * current_index], arb[2 * current_index + 1]);
}

int main()
{
    std::ifstream f("arbint.in");
    std::ofstream g("arbint.out");

    int n, m;
    f >> n >> m;

    std::vector<int> v(n, 0);
    std::vector<int> arbint(200001, 0);

    for (int i = 0; i < n; i++) {
        f >> v[i];
    }

    build(arbint, v, 1, 0, n - 1);

    int command, a, b;
    for (int i = 0; i < m; i++) {
        f >> command >> a >> b;
        if (!command) {
            g << maxim(arbint, 1, 1, n, a, b) << "\n";
        }
        else {
            update(arbint, 1, a, b, 1, n);
        }
    }


}