#include<fstream>
#include<vector>
using namespace std;


class InParser {
    vector<char> str;
    int ptr;
    ifstream fin;

    char getChar() {
        if (ptr == int(str.size())) {
            fin.read(str.data(), str.size());
            ptr = 0;
        }
        return str[ptr++];
    }

    template<class T>
    T getInt() {
        char chr = getChar();
        while (!isdigit(chr) && chr != '-')
            chr = getChar();
        int sgn = +1;
        if (chr == '-') {
            sgn = -1;
            chr = getChar();
        }
        T num = 0;
        while (isdigit(chr)) {
            num = num * 10 + chr - '0';
            chr = getChar();
        }
        return sgn * num;
    }

public:
    InParser(const char* name) : str(1e5), ptr(str.size()), fin(name) { }
    ~InParser() { fin.close(); }

    template<class T>
    friend InParser& operator>>(InParser& in, T& num) {
        num = in.getInt<T>();
        return in;
    }
};


class OutParser {
    vector<char> str;
    int ptr;
    ofstream fout;

    void putChar(char chr) {
        if (ptr == int(str.size())) {
            fout.write(str.data(), str.size());
            ptr = 0;
        }
        str[ptr++] = chr;
    }

    template<class T>
    void putInt(T num) {
        if (num < 0) {
            putChar('-');
            num *= -1;
        }
        if (num > 9)
            putInt(num / 10);
        putChar(num % 10 + '0');
    }

public:
    OutParser(const char* name) : str(1e5), ptr(0), fout(name) { }
    ~OutParser() { fout.write(str.data(), ptr); fout.close(); }

    template<class T>
    friend OutParser& operator<<(OutParser& out, const T num) {
        out.putInt(num);
        return out;
    }

    friend OutParser& operator<<(OutParser& out, const char chr) {
        out.putChar(chr);
        return out;
    }

    friend OutParser& operator<<(OutParser& out, const char* str) {
        for (int i = 0; str[i]; i++)
            out.putChar(str[i]);
        return out;
    }
};

vector<int> aint;

int query(int nod,int st,int dr,int ql,int qr)
{
    if(ql <= st && qr >= dr)
        return aint[nod];

    if(ql > dr || qr < st)
        return 0;

    int mid = (st + dr) / 2;
    int stanga = query(nod * 2,st,mid,ql,qr);
    int dreapta = query(nod * 2 + 1,mid + 1,dr,ql,qr);

    return max(stanga,dreapta);
}

void update(int nod,int val,int n)
{
    aint[nod + n] = val;
    for(int tata = (nod + n) / 2; tata >= 1; tata /= 2)
        {
            aint[tata] = max(aint[tata * 2],aint[tata * 2 + 1]);
        }
}

int main()
{
    InParser cin("arbint.in");
    OutParser cout("arbint.out");

    int n,q;
    cin >> n >> q;
    vector<int> a(n);

    for(int i = 0 ; i < n ; i++)
        {
            cin >> a[i];
        }

    while(__builtin_popcount(n) != 1)
        {
            a.push_back(0);
            n++;
        }

    aint.resize(n * 2);

    //build

    for(int i = 0 ; i < n ; i++)
        {
            aint[n + i] = a[i];
        }


    for(int i = n - 1; i >= 1 ; i--)
        {
            aint[i] = max(aint[i * 2],aint[i * 2 + 1]);
        }

    //query


    while(q--)
        {
            int t,l,r;
            cin >> t >> l >> r;

            if(t == 0)
                {
                    l--,r--;
                    int rez = query(1,0,n - 1,l,r);
                    cout << rez << '\n';
                }
            else
                {
                    update(l - 1,r,n);
                }
        }

    return 0;

}