#include <bits/stdc++.h>
#define pb push_back
#define pii pair<int, int>
using ll = long long;
using ci = const int;
using cll = const long long;

using namespace std;

const int NMAX = 1e5 + 5;
const int NRMAX = 1e6 + 5;
/*******************************/
// INPUT / OUTPUT

ifstream f("arbint.in");
ofstream g("arbint.out");
/*******************************/
/// GLOBAL DECLARATIONS

int N, Q;
int v[NMAX];
int rez;
int lazy[4 * NMAX], arb[4 * NMAX];
/*******************************/
/// FUNCTIONS

void ReadInput();
void Solution();
void Output();
/*******************************/
///-------------------------------------
inline void ReadInput()
{
    f >> N >> Q;

    for (int i = 1 ; i <= N ; ++ i)
        f >> v[i];
}
///-------------------------------------
void update_lazy(int st, int dr, int node)
{
    arb[node] = lazy[node];
    if (st != dr)
    {
        lazy[2 * node] = lazy[node];
        lazy[2 * node + 1] = lazy[node];
    }
    lazy[node] = 0;
    return;
}
///-------------------------------------
void uneste_noduri(int st, int dr, int &rez)
{
    rez = min(st, dr);
}
///-------------------------------------
void update(int arbSt, int arbDr, int st, int dr, int node, int val)
{    
    if (lazy[node] != 0)
        update_lazy(arbSt, arbDr, node);

    if ((arbDr < st) || (arbSt > dr)) return;

    if ((st <= arbSt) && (arbDr <= dr))
    {
        lazy[node] = val;
        update_lazy(arbSt, arbDr, node);
        return;
    }

    int mid = (arbSt + arbDr) / 2;
    update(arbSt, mid, st, dr, 2 * node, val);
    update(mid + 1, arbDr, st, dr, 2 * node + 1, val);

    arb[node] = max(arb[2 * node], arb[2 * node + 1]);  
    return;
}
///-------------------------------------
int query(int arbSt, int arbDr, int st, int dr, int node)
{
    if (lazy[node] != 0)
        update_lazy(arbSt, arbDr, node);

    if ((arbDr < st) || (arbSt > dr))
        return 0;

    if ((st <= arbSt) && (arbDr <= dr))
        return arb[node];

    int mid = (arbSt + arbDr) / 2;
    int q1 = query(arbSt, mid, st, dr, 2 * node);
    int q2 = query(mid + 1, arbDr, st, dr, 2 * node + 1);

    return max(q1, q2);
}
///-------------------------------------
void build(int st, int dr, int node)
{
    if (st == dr)
    {
        arb[node] = v[st];
        return;
    }

    int mid = (st + dr) / 2;
    build(st, mid, 2 * node);
    build(mid + 1, dr, 2 * node + 1);

    arb[node] = max(arb[2 * node], arb[2 * node + 1]);  
    return;
}
///-------------------------------------
inline void Solution()
{
    build(1, N, 1);
    int tip, st, dr, val;
    while (Q --)
    {
        f >> tip >> st >> dr;

        if (tip == 0)
        {
            rez = query(1, N, st, dr, 1);
            g << rez << "\n";
            continue;
        }
        update(1, N, st, st, 1, dr);
        
    }
}
///-------------------------------------
inline void Output()
{

}
///-------------------------------------
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    ReadInput();
    Solution();
    Output();
    return 0;
}