#include <iostream>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <limits.h>
#include <chrono>
#include <numeric>
#include <iomanip>

#include <vector>
#include <string>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <bitset>
#include <deque>  
#include <stack>
#include <queue>
#include <list>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<string, string> pss;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<bool> vb;
typedef vector<vb> vvb;
 
double EPS = 1e-9;
int INF = 1000000005;
long long INFF = 1000000000000000005LL;
double PI = acos(-1);

#define M 1000000007

#define rall(x) (x).rbegin(), (x).rend()
#define all(x) (x).begin(), (x).end()

// auto lim=unique(all(v));
// v.resize(distance(v.begin(), lim));

struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};

struct pair_custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    template <class T1, class T2>
    size_t operator()(const pair<T1, T2>& p) const
    {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();

        auto hash1 = splitmix64(p.first+FIXED_RANDOM);
        auto hash2 = splitmix64(p.second+FIXED_RANDOM);
 
        return hash1^hash2;
    }
};

template<class T> T nxt() {
    T x;
    cin >> x;
    return x;
}

struct SegmentTree{
    int leftmost,rightmost;
    SegmentTree* leftChild;
    SegmentTree* rightChild;

    int maxValue;

    SegmentTree(const int& leftmost,const int& rightmost,const vl& elements){
        this->leftmost=leftmost;
        this->rightmost=rightmost;
        if(leftmost==rightmost){
            this->leftChild=this->rightChild=nullptr;

            this->maxValue=elements[leftmost];
        }
        else{
            int middle=(leftmost+rightmost)/2;

            // Take from [l,m] and [m+1,r]
            this->leftChild=new SegmentTree(leftmost,middle,elements);
            this->rightChild=new SegmentTree(middle+1,rightmost,elements);

            recalculate();
        }
    }

    void recalculate(){
        if(leftmost==rightmost){
           return;
        }
        
        maxValue=max(leftChild->maxValue,rightChild->maxValue);
    }

    void pointUpdate(const int& index,const ll& value){
        if(leftmost==rightmost){
            maxValue=value;
            return;
        }

        if(index<=leftChild->rightmost){
            leftChild->pointUpdate(index,value);
        }
        else{
            rightChild->pointUpdate(index,value);
        }

        recalculate();
    }

    ll rangeQuery(const int& left,const int& right){
        // 1. Entirely disjoint
        if(right<leftmost||left>rightmost){
            return 0;
        }

        // 2.Covers us
        if(left<=leftmost&&right>=rightmost){
            return maxValue;
        }

        // 3.Has intersection
        return max(leftChild->rangeQuery(left,right),rightChild->rangeQuery(left,right));
    }
};

void Solve(){
    int n,m;
    cin>>n>>m;
    vl v(n);
    generate(all(v),nxt<ll>);

    SegmentTree segmentTree=SegmentTree(0,n-1,v);
    for(int i=0;i<m;++i){
        int t,a,b;
        cin>>t>>a>>b;

        --a;
        if(t==0){
            --b;
            cout<<segmentTree.rangeQuery(a,b)<<'\n';
        }
        else{
            segmentTree.pointUpdate(a,b);
        }
    }
}

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    freopen("arbint.in", "r", stdin);
    freopen("arbint.out", "w", stdout);

    // std::string file="";
    // std::ifstream in(file+".in");
    // std::streambuf *cinbuf = std::cin.rdbuf(); //save old buf
    // cin.rdbuf(in.rdbuf()); //redirect std::cin
    
    // std::ofstream out(file+".out");
    // std::streambuf *coutbuf = std::cout.rdbuf(); //save old buf
    // cout.rdbuf(out.rdbuf()); //redirect std::cout

    Solve();

    // std::cin.rdbuf(cinbuf);   //reset to standard input again
    // std::cout.rdbuf(coutbuf); //reset to standard output again

    return 0;
}