#include <bits/stdc++.h>
using namespace std;

class segment_tree {
public:
    segment_tree(const vector<int>& data) :
            size_(data.size()){
        data_.resize(4 * size_);
        build(1, 0, data.size() - 1, data);
    }

    void update(size_t position, int value) {
        update(1, 0, size_ - 1, position, value);
    }

    int query(size_t left, size_t right) {
        return query(1, 0, size_ - 1, left, right);
    }

private:
    void build(int node, size_t left, size_t right, const vector< int >& data) {
        if (left == right) {
            data_[node] = data[left];
            return;
        }

        size_t middle = (left + right) / 2;
        build(2*node, left, middle, data);
        build(2*node+1, middle+1, right, data);

        data_[node] = max(data_[2*node], data_[2*node+1]);
    }

    void update(int node, size_t left, size_t right, size_t position, int value) {
        if (left == right) {
            data_[node] = value;
            return;
        }

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

        data_[node] = max(data_[2*node], data_[2*node+1]);
    }

    int query(int node, size_t left, size_t right, size_t query_left, size_t query_right) {
        if (query_left <= left && right <= query_right)
            return data_[node];

        size_t middle = (left + right) / 2;
        int maxim = -1;
        if (query_left <= middle)
            maxim = max(maxim, query(2*node, left, middle, query_left, query_right));
        if (middle < query_right)
            maxim = max(maxim, query(2*node+1, middle+1, right, query_left, query_right));

        return maxim;
    }

    size_t size_;
    vector< int > data_;
};

void solve() {
    size_t size, query_count;
    cin >> size >> query_count;

    vector< int > values(size);
    for (auto& it : values)
        cin >> it;

    segment_tree value_manager(values);

    while (query_count--) {
        int operation, a, b;
        cin >> operation >> a >> b;

        if (operation == 0)
            cout << value_manager.query((size_t)a - 1, (size_t)b - 1) << '\n';
        else
            value_manager.update((size_t)a - 1, b);
    }
}

int main() {
    assert(freopen("arbint.in", "r", stdin));
    assert(freopen("arbint.out", "w", stdout));
    cin.tie(nullptr);
    ios_base::sync_with_stdio(false);

    solve();

    return 0;
}