#include <vector>
#include <limits>
#include <iostream>
#include <fstream>


 class MaxTree {
public:

    MaxTree(int N): N_{N}, maxTree_(4 * N_ + 1, std::numeric_limits<int>::min())  {
    } 

    int query(int start, int end) {
        return queryImpl(1, 1, N_, start, end);
    }

    void update(int pos, int val) {
        updateImpl(1, 1, N_, pos, val);
    }


private:

    int queryImpl(int node, int left, int right, const int start, const int end) {
        if ( left >= start && right <= end) {
            return maxTree_[node];
        }

        int middle = (left + right) >> 1;
        int ans = std::numeric_limits<int>::min();
        if (start <= middle) {
            ans = queryImpl(node << 1, left, middle, start, end);
        }

        if (end > middle) {
            ans = std::max(ans, queryImpl( (node << 1) | 1, middle + 1, right, start, end));
        }

        return ans;
    }

    void updateImpl(int node, int left, int right, const int pos, const int val) {
        if (left == right) {
            maxTree_[node] = val;
            return ;
        }

        int middle = (left + right) >> 1;
        if (pos <= middle) {
            updateImpl(node << 1, left, middle, pos, val);
        } else {
            updateImpl( (node << 1) | 1, middle + 1, right, pos, val);
        }

        maxTree_[node] = std::max(maxTree_[node << 1], maxTree_[(node << 1) | 1]);
    }

    const int N_;
    std::vector<int> maxTree_;
};

int main() {
    int N, M, op, a, b;
    std::ifstream in{"arbint.in"};
    std::ofstream out{"arbint.out"};

    in >> N >> M;
    MaxTree tree{N};
    for (int i = 1; i <= N; ++i) {
        in >> a;
        tree.update(i, a);
    }
    for (int i = 0; i < M; ++i) {
        in >> op >> a >> b;
        if (op == 0) {
            out << tree.query(a, b) << '\n';
        } else {
            tree.update(a, b);
        }
    }


    return 0;

}