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

using namespace std;

struct Node {
    int value;
    int start;
    int end;
};

vector<Node> segmentTree;

void buildSegmentTree(const vector<int>& input, int node, int start, int end) {
    if (start == end) {
        segmentTree[node].value = input[start];
        segmentTree[node].start = start;
        segmentTree[node].end = end;
        return;
    }

    int mid = (start + end) / 2;
    buildSegmentTree(input, 2 * node, start, mid);
    buildSegmentTree(input, 2 * node + 1, mid + 1, end);

    segmentTree[node].value = max(segmentTree[2 * node].value, segmentTree[2 * node + 1].value);
    segmentTree[node].start = start;
    segmentTree[node].end = end;
}

int query(const vector<int>& input, int node, int start, int end, int rangeStart, int rangeEnd) {
    if (rangeStart <= start && rangeEnd >= end) {
        return segmentTree[node].value;
    }

    if (rangeEnd < start || rangeStart > end) {
        return 0;
    }

    int mid = (start + end) / 2;
    int leftValue = query(input, 2 * node, start, mid, rangeStart, rangeEnd);
    int rightValue = query(input, 2 * node + 1, mid + 1, end, rangeStart, rangeEnd);

    return max(leftValue, rightValue);
}

void update(vector<int>& input, int node, int start, int end, int index, int value) {
    if (start == end) {
        segmentTree[node].value = value;
        input[index] = value;
        return;
    }

    int mid = (start + end) / 2;
    if (index >= start && index <= mid) {
        update(input, 2 * node, start, mid, index, value);
    } else {
        update(input, 2 * node + 1, mid + 1, end, index, value);
    }

    segmentTree[node].value = max(segmentTree[2 * node].value, segmentTree[2 * node + 1].value);
}

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

    int N, M;
    inputFile >> N >> M;

    vector<int> input(N + 1);
    for (int i = 1; i <= N; i++) {
        inputFile >> input[i];
    }

    segmentTree.resize(4 * N);
    buildSegmentTree(input, 1, 1, N);

    for (int i = 0; i < M; i++) {
        int type, a, b;
        inputFile >> type >> a >> b;

        if (type == 0) {
            int result = query(input, 1, 1, N, a, b);
            outputFile << result << "\n";
        } else {
            update(input, 1, 1, N, a, b);
        }
    }

    inputFile.close();
    outputFile.close();

    return 0;
}