#include <iostream>
#include <fstream>
#include <vector>
#include <cassert>
#include <algorithm>

std::vector<int> v;
struct Base {
    int value, left, right;
};

struct Leaf: Base {};

struct Node: Base {
    Base *left_child, *right_child;
};

Base* root;

Base* rec(int left, int right) {
    if(right + ~left) {
        Node* node = new Node();
        node->left = left;
        node->right = right;

        int middle = (left + right)>>1;
        node->left_child = rec(left, middle);
        node->right_child= rec(middle, right);
        node->value = std::max(
            node->left_child->value,
            node->right_child->value); 
        return node;
    }
    Leaf* leaf = new Leaf();
    leaf->left = left;
    leaf->right= right;
    leaf->value = v[left];
}

void change(Base* base, int pos, int value) {
    if(base->right+~base->left)
    {
        Node* node=(Node*)base;
        int middle = (base->right + base->left)>>1;
        if(pos<middle) {
            change(node->left_child, pos, value);   
        }
        else {
            change(node->right_child, pos, value);
        }
        node->value = std::max(
            node->left_child->value,
            node->right_child->value);
    }
    else
    {
        base->value=value;
    }
}

int max_range(Base* base, int left, int right) {
    if(base->left == left and base->right == right) {
        return base->value;
    }
    Node* node = (Node*)base;
    int middle = (node->left + node->right)>>1;
    if(right <= middle) {
        return max_range(node->left_child, left, right);
    }
    else if (left>=middle) {
        return max_range(node->right_child, left, right); 
    }
    // left < middle < right
    return std::max(
        max_range(node->left_child, left, middle),
        max_range(node->right_child, middle, right));
}

int main () {
    std::ifstream fin("arbint.in");
    std::ofstream fout("arbint.out");
    int n,m,x;
    fin>>n>>m; 
    v.push_back(0);
    for(int i=0;i<n;i++)
    {
        fin>>x; 
        v.push_back(x);
    }
    int opt,a,b;
    root = rec(1, v.size()+1);
    for(int i=0;i<m;i++)
    {
        fin>>opt>>a>>b;     
        if (opt==0)
        {
            fout<<max_range(root, a, b+1)<<std::endl;
        }
        else
        {
            change(root, a, b);
        }
    }
    return 0;
}