#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;
}