#include <fstream>
#include <vector>
#include <algorithm>

#define MAX_N 100000
#define MAX_INTERVAL_TREE_NODES 2000000

using namespace std;

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

struct Node {
    int st;
    int dr;
    int maxi;
};

int N, M, qType, qa, qb;
vector<int> a(MAX_N + 1);
vector<Node> nodes(MAX_INTERVAL_TREE_NODES + 1);

int constructIntervalTree(int node, int st, int dr) {
    nodes[node].st = st;
    nodes[node].dr = dr;
    
    if (st < dr) {
        int mij = (st + dr) / 2;
        nodes[node].maxi = max(
            constructIntervalTree(node * 2, st, mij),
            constructIntervalTree(node * 2 + 1, mij + 1, dr)
        );
    } else {
        nodes[node].maxi = a[st];
    }
    
    return nodes[node].maxi;
}

int queryIntervalTree(int node, int st, int dr) {
    if (nodes[node].st >= st && nodes[node].dr <= dr) {
        return nodes[node].maxi;
    }
    
    int mij = (nodes[node].st + nodes[node].dr) / 2;
    int valSubarbSt = 0, valSubarbDr = 0;
    
    if (st <= mij) {
        valSubarbSt = queryIntervalTree(node * 2, st, dr);
    }
    
    if (dr > mij) {
        valSubarbDr = queryIntervalTree(node * 2 + 1, st, dr);
    }
    
    return max(valSubarbSt, valSubarbDr);
}

int updateIntervalTree(int node, int pos, int val) {
    if (nodes[node].st == nodes[node].dr) {
        nodes[node].maxi = val;
        return nodes[node].maxi;
    }
    
    int mij = (nodes[node].st + nodes[node].dr) / 2;
    
    int newMaxi = 0;
    if (pos <= mij) {
        newMaxi = updateIntervalTree(node * 2, pos, val);
    } else {
        newMaxi = updateIntervalTree(node * 2 + 1, pos, val);
    }
    
    nodes[node].maxi = max(nodes[node * 2].maxi, nodes[node * 2 + 1].maxi);
    return nodes[node].maxi;
}

int main() {
    cin >> N >> M;
    
    for (int i = 1; i <= N; ++i) {
        cin >> a[i];
    }
    
    constructIntervalTree(1, 1, N);
    
    int currentNode = 1;
    
    for (int i = 0; i < M; ++i) {
        cin >> qType >> qa >> qb;
        
        if (qType == 0) {
            cout << queryIntervalTree(1, qa, qb) << '\n';
        } else {
            updateIntervalTree(1, qa, qb);
        }
    }
    
    return 0;
}