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

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

inline int updateNode(int value1, int value2)
{
    return max(value1, value2);
}


inline void updateLazy(pair<int, int> *tree, int node, bool oki)
{
    if (tree[node].second != -1) {
        tree[node].first = tree[node].second;
        
        if (oki) {
            tree[node << 1].second = tree[node].second;
            tree[node << 1 | 1].second = tree[node].second;
        }
        
        tree[node].second = -1;
    }
}

template <class Type>
class SegmentTree {
private:
    int treeSize;
    int _left, _right;
    
    Type _value;
    pair<Type, Type> *tree;
    
    void _build(int node, int left, int right, Type* array)
    {
        tree[node].second = -1;
        
        if (left == right) {
            tree[node].first = array[left];
            return;
        }
        
        int middle = (left + right) >> 1;
        
        _build(node << 1, left, middle, array);
        _build(node << 1 | 1, middle + 1, right, array);
        
        tree[node].first = updateNode(tree[node << 1].first, tree[node << 1 | 1].first);
    }
    
    void _update(int node, int left, int right)
    {
        updateLazy(tree, node, left != right);
        
        if (_left <= left and right <= _right) {
            tree[node].second = _value;
            updateLazy(tree, node, left != right);
            return;
        }
        
        int middle = (left + right) >> 1;
        
        if (_left <= middle)
            _update(node << 1, left, middle);
        if (middle < _right)
            _update(node << 1 | 1, middle + 1, right);
        
        tree[node].first = updateNode(tree[node << 1].first, tree[node << 1 | 1].first);
    }
    
    Type _query(int node, int left, int right)
    {
        updateLazy(tree, node, left != right);
        
        if (_left <= left and right <= _right)
            return tree[node].first;
        
        int middle = (left + right) >> 1;
        
        if (_right <= middle)
            return _query(node << 1, left, middle);
        if (middle < _left)
            return _query(node << 1 | 1, middle + 1, right);
        
        return updateNode(_query(node << 1, left, middle), _query(node << 1 | 1, middle + 1, right));
    }
    
public:
    SegmentTree(int size)
    {
        tree = new pair<int, int>[size << 2]; treeSize = size;
    }
    
    SegmentTree(int size, int value)
    {
        tree = new pair<int, int>[size << 2]; treeSize = size;
        _build(1, 1, treeSize, value);
    }
    
    inline void build(Type* array)
    {
        _build(1, 1, treeSize, array);
    }
    
    inline void update(int left, int right, Type value)
    {
        _left = left; _right = right; _value = value;
        _update(1, 1, treeSize);
    }
    
    inline Type query(int left, int right)
    {
        _left = left; _right = right;
        return _query(1, 1, treeSize);
    }
}; SegmentTree<int> segmentTree(1e5);

const int DIM = 1e5 + 5;

int arr[DIM];

int main(void)
{
    int n, q;
    in >> n >> q;
    
    for (int i = 1; i <= n; ++i)
        in >> arr[i];

    segmentTree.build(arr);
    
    while (q--) {
        int t, x, y;
        in >> t >> x >> y;
        
        switch(t) {
        case 1:
            segmentTree.update(x, x, y);
            break;
        case 0:
            out << segmentTree.query(x, y) << "\n";
            break;
        }
    }
    
    return 0;
}