#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define ar array
#define vt vector
#define pq priority_queue
#define pu push
#define pub push_back
#define em emplace
#define emb emplace_back

#define all(x) x.begin(), x.end()
#define allr(x) x.rbegin(), x.rend()
#define allp(x, l, r) x.begin() + l, x.begin() + r
#define len(x) (int)x.size()

using namespace std;
using namespace __gnu_pbds;

using ll = long long;
using ld = long double;
using ull = unsigned long long;

template <class T, size_t N>
void re(array <T, N>& x);
template <class T> 
void re(vt <T>& x);

template <class T> 
void re(T& x) {
    cin >> x;
}

template <class T, class... M> 
void re(T& x, M&... args) {
    re(x); re(args...);
}

template <class T> 
void re(vt <T>& x) {
    for(auto& it : x)
        re(it);
}

template <class T, size_t N>
void re(array <T, N>& x) {
    for(auto& it : x)
        re(it);
}

template <class T, size_t N>
void wr(array <T, N> x);
template <class T> 
void wr(vt <T> x);

template <class T> 
void wr(T x) {
    cout << x;
}

template <class T, class ...M>  void wr(T x, M... args) {
    wr(x), wr(args...);
}

template <class T> 
void wr(vt <T> x) {
    for(auto it : x)
        wr(it, ' ');
}

template <class T, size_t N>
void wr(array <T, N> x) {
    for(auto it : x)
        wr(it, ' ');
}


inline void Open(const string Name) {
    #ifndef ONLINE_JUDGE
        (void)!freopen((Name + ".in").c_str(), "r", stdin);
        (void)!freopen((Name + ".out").c_str(), "w", stdout);
    #endif
}


struct ST {
    #define vl v * 2 + 1
    #define vr v * 2 + 2

    const int inf = 1e9 + 1;

    int n;
    vt <int> t;

    ST() {}
    ST(int _n) {
        n = _n;
        t.resize(4 * n + 10);
    }

    void init(int _n) {
        n = _n;
        t.resize(4 * n + 10);
    }

    void build(const vt <int>& a, int v, int tl, int tr) {
        if (tl == tr) {
            t[v] = a[tl];
            return;
        }

        int tm = (tl + tr) / 2;
        build(a, vl, tl, tm);
        build(a, vr, tm + 1, tr);
        t[v] = max(t[vl], t[vr]);
    }

    void build(const vt <int>&a) {
        build(a, 0, 0, n - 1);
    }

    void upd(int v, int tl, int tr, int pos, int val) {
        if (tl > pos or tr < pos) {
            return;
        }

        if (tl == pos and pos == tr) {
            t[v] = val;
            return;
        }

        int tm = (tl + tr) / 2;
        upd(vl, tl, tm, pos, val);
        upd(vr, tm + 1, tr, pos, val);
        t[v] = max(t[vl], t[vr]);
    }

    void upd(int pos, int val) {
        upd(0, 0, n - 1, pos, val);
    }

    int query(int v, int tl, int tr, int l, int r) {
        if (tl > r or tr < l) {
            return -inf;
        }

        if (l <= tl and tr <= r) {
            return t[v];
        }

        int tm = (tl + tr) / 2;
        int L = query(vl, tl, tm, l, r);
        int R = query(vr, tm + 1, tr, l, r);
        return max(L, R);
    }

    int query(int l, int r) {
        return query(0, 0, n - 1, l, r);
    }
};

void solve() {
    /* standard algorithm */
    int n, q; re(n, q);
    vt <int> a(n); re(a);
    ST t(n);
    t.build(a);

    while (q--) {
        int task, a, b; re(task, a, b);
        if (task == 0) {
            wr(t.query(a - 1, b - 1), '\n');
        } else {
            t.upd(a - 1, b);
        }
    }

}

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

    //Open("");

    int t = 1;
    for(;t;t--) {
        solve();
    }
    
    return 0;
}