#include <fstream>
#include <vector>

using namespace std;

const int NMAX = 1e5;
int N, M;
class SegmentTree {
private:
    int nodes;
    vector <int> values;
    vector <int> seg_tree;
    int LeftSon(int node) {
        return 2 * node;
    }
    int RightSon(int node) {
        return 2 * node + 1;
    }
    void Build(int node, int left, int right) {
        if (left == right) {
            seg_tree[node] = values[left];
        }
        else {
            int mid = (left + right) / 2;
            Build(LeftSon(node), left, mid);
            Build(RightSon(node), mid + 1, right);
            seg_tree[node] = max(seg_tree[LeftSon(node)], seg_tree[RightSon(node)]);
        }
    }
    void Update(int node, int left, int right, const int& pos, const int& val) {
        if (left == right) {
            seg_tree[node] = val;
        }
        else {
            int mid = (left + right) / 2;
            if (pos <= mid) {
                Update(LeftSon(node), left, mid, pos, val);
            }
            else {
                Update(RightSon(node), mid + 1, right, pos, val);
            }
            seg_tree[node] = max(seg_tree[LeftSon(node)], seg_tree[RightSon(node)]);
        }
    }
    int Query(int node, int left, int right, const int& LeftQuery, const int& RightQuery) {
        if (LeftQuery <= left && right <= RightQuery) {
            return seg_tree[node];
        }
        else {
            int mid = (left + right) / 2;
            int answer = -(1 << 30);
            if (LeftQuery <= mid) {
                answer = max(answer, Query(LeftSon(node), left, mid, LeftQuery, RightQuery));
            }
            if (RightQuery > mid) {
                answer = max(answer, Query(RightSon(node), mid + 1, right, LeftQuery, RightQuery));
            }
            return answer;
        }
    }
public:
    SegmentTree(vector <int> v) {
        values = v;
        nodes = values.size() - 1;
        seg_tree = vector <int>(4 * nodes, -(1 << 30));
        Build(1, 1, nodes);
    }
    void Update(const int& pos, const int& val) {
        return Update(1, 1, nodes, pos, val);
    }
    int Query(const int& LeftQuery, const int& RightQuery) {
        return Query(1, 1, nodes, LeftQuery, RightQuery);
    }
        
};

int main() {
    ifstream fin("arbint.in");
    ofstream fout("arbint.out");
    fin >> N >> M;
    vector <int> v(N + 1, 0);
    for (int i = 1; i <= N; ++i) {
        fin >> v[i];
    }
    SegmentTree s(v);
    for (int i = 1; i <= M; ++i) {
        int type;
        fin >> type;
        if (type == 0) {
            int left, right;
            fin >> left >> right;
            fout << s.Query(left, right) << "\n";
        }
        else {
            int pos, val;
            fin >> pos >> val;
            s.Update(pos, val);
        }
    };
    fin.close();
    fout.close();
    return 0;
}