#include <fstream>
#include <vector>
#include <climits>

using namespace std;

ifstream cin("arbint.in");
ofstream cout("arbint.out");

int n, m;
vector<int> v;

class SegmentTree {
    vector<int> tree;
    int size;
    int left_son(int node) { return node + 1; }
    int right_son(int node, int middle, int left) { return node + 2 * (middle - left + 1); }
    void _build(int node, int start, int finish) {
        if (start == finish) {
            tree[node] = v[start];
            return;
        }
        int middle = (start + finish) / 2;
        _build(left_son(node), start, middle);
        _build(right_son(node, middle, start), middle + 1, finish);
        tree[node] = max(tree[left_son(node)], tree[right_son(node, middle, finish)]);
    }
    void _update(int node, int start, int finish, int position, int value) {
        if (start == finish) {
            tree[node] = value;
            return;
        }
        int middle = (start + finish) / 2;
        if (position <= middle) {
            _update(left_son(node), start, middle, position, value);
        } else {
            _update(right_son(node, middle, start), middle + 1, finish, position, value);
        }
        tree[node] = max(tree[left_son(node)], tree[right_son(node, middle, finish)]);
    }
    void _query(int node, int start, int finish, int query_start, int query_finish, int &ans) {
        if (query_start <= start && query_finish >= finish) {
            ans = max(ans, tree[node]);
            return;
        }
        int middle = (start + finish) / 2;
        if (query_start <= middle) {
            _query(left_son(node), start, middle, query_start, query_finish, ans);
        }
        if (query_finish > middle) {
            _query(right_son(node, middle, start), middle + 1, finish, query_start, query_finish, ans);
        }
    }
public:
    SegmentTree(int size) {
        this->size = size;
        tree.assign(2 * n + 2, 0);
        _build(1, 1, size);
    }
    void update(int position, int value) {
        _update(1, 1, size, position, value);
    }
    void query(int query_start, int query_finish, int &ans) {
        _query(1, 1, size, query_start, query_finish, ans);
    }
};

int main() {
    cin >> n >> m;
    v.assign(n + 2, 0);
    for (int i = 1 ; i <= n ; ++i) {
        cin >> v[i];
    }
    SegmentTree t(n);
    for (int i = 1 ; i <= m ; ++i) {
        int op, a, b;
        cin >> op >> a >> b;
        if (op == 0) {
            int ans = INT_MIN;
            t.query(a, b, ans);
            cout << ans << "\n";
        }
        if (op == 1) {
            t.update(a, b);
        }
    }
}