#include <fstream>
#include <algorithm>

const int N = 100005;

int segment_tree[N * 4], array[N];

void build(int node, int left, int right)
{
    if (left == right) {
        segment_tree[node] = array[left];
    } else {
        int middle = (left + right) / 2;

        build(node * 2, left, middle);
        build(node * 2 + 1, middle + 1, right);

        segment_tree[node] = std::max(segment_tree[node * 2],
                                      segment_tree[node * 2 + 1]);
    }
}

void update(int node, int left, int right, int position, int new_value)
{
    if (left == right) {
        segment_tree[node] = new_value;
    } else {
        int middle = (left + right) / 2;

        if (position <= middle)
            update(node * 2, left, middle, position, new_value);
        else
            update(node * 2 + 1, middle + 1, right, position, new_value);

        segment_tree[node] = std::max(segment_tree[node * 2],
                                      segment_tree[node * 2 + 1]);
    }
}

int query(int node, int left, int right, int query_left, int query_right)
{
    if (query_left <= left and right <= query_right) {
        return segment_tree[node];
    } else {
        int middle = (left + right) / 2;

        if (query_right <= middle)
            return query(node * 2, left, middle, query_left, query_right);
        if (middle + 1 <= query_left)
            return query(node * 2 + 1, middle + 1, right, query_left, query_right);

        return std::max(query(node * 2, left, middle, query_left, query_right),
                        query(node * 2 + 1, middle + 1, right, query_left, query_right));
    }
}

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

    int n, q;
    in >> n >> q;

    for (int i = 1; i <= n; ++i)
        in >> array[i];

    build(1, 1, n);

    while (q--) {
        int t;
        in >> t;

        if (t == 0) {
            int left, right;
            in >> left >> right;
            out << query(1, 1, n, left, right) << "\n";
        } else {
            int position, new_value;
            in >> position >> new_value;
            update(1, 1, n, position, new_value);
        }
    }

    return 0;
}