//  PROBLEMA 5 - oferta
#include <fstream>
#include <vector>
#include <iomanip>
#include <algorithm>
#include <stack>
#include<queue>

using namespace std;

const int NMAX = 100010;

int aint[4 * NMAX + 5], lazy[4 * NMAX + 5];

void update(int node, int l, int r, int poz, int val) {
    if (l == r) {
        aint[node] = val;
        return;
    }
    int mid = (l + r) >> 1;
    int stanga = node << 1;
    int dreapta = stanga | 1;
    if (poz <= mid) {
        update(stanga, l, mid, poz, val);
    }
    else {
        update(dreapta, mid + 1, r, poz, val);
    }
    aint[node] = max(aint[stanga], aint[dreapta]);
    return;
}

int querry(int node, int l, int r, int lq, int rq) {
    if (lq <= l && rq >= r) {
        return aint[node];
    }
    int mid = (l + r) >> 1;
    int stanga = node << 1;
    int dreapta = stanga | 1;
    int x = 0, y = 0;
    if (mid >= lq) {
        x = querry(stanga, l, mid, lq, rq);
    }
    if (mid + 1 <= rq) {
        y = querry(dreapta, mid + 1, r, lq, rq);
    }
    return max(x, y);
}


struct DSU {
    vector<int> parent, sizes;

    void init(int N) {
        parent.resize(N + 2);
        sizes.resize(N + 2);
        for (int i = 0; i < N; i++) {
            parent[i] = i;
            sizes[i] = 1;
        }
    }

    int findParent(int x) {
        if (parent[x] == x) {
            return x;
        }
        return parent[x] = findParent(parent[x]);
    }

    void unite(int x, int y) {
        x = findParent(x);
        y = findParent(y);
        if (x == y)
            return;
        if (sizes[y] < sizes[x])
            swap(x, y);
        parent[x] = y;
        sizes[y] += sizes[x];
        return;
    }

};

void lazyUpdate(int node, int l, int r, int lq, int rq, int val) {
    int mid = (l + r) >> 1;
    int stanga = node << 1;
    int dreapta = stanga | 1;

    if (lazy[node] != 0) {
        aint[node] = lazy[node];
        if (l != r) {
            lazy[stanga] = lazy[node];
            lazy[dreapta] = lazy[node];
        }
        lazy[node] = 0;
    }

    if (lq <= l && rq >= r) {
        aint[node] = val;
        if (l != r) {
            lazy[stanga] = val;
            lazy[dreapta] = val;
        }
        return;
    }
    if (mid >= lq) {
        lazyUpdate(stanga, l, mid, lq, rq, val);
    }
    if (mid + 1 <= rq) {
        lazyUpdate(dreapta, mid + 1, r, lq, rq, val);
    }
    aint[node] = max(aint[stanga], aint[dreapta]);
}

int lazyquerry(int node, int l, int r, int lq, int rq) {
    int mid = (l + r) >> 1;
    int stanga = node << 1;
    int dreapta = stanga | 1;
    if (lazy[node] != 0) {
        aint[node] = lazy[node];
        if (l != r) {
            aint[stanga] = lazy[node];
            aint[dreapta] = lazy[node];
        }
        lazy[node] = 0;
    }
    if (lq <= l && rq >= r) {
        return aint[node];
    }
    int x, y = 0;
    if (mid >= lq) {
        x = lazyquerry(stanga, l, mid, lq, rq);
    }
    if (mid + 1 <= rq) {
        y = lazyquerry(dreapta, mid + 1, r, lq, rq);
    }
    return max(x, y);
}


int main() {

    ifstream cin("arbint.in");
    ofstream cout("arbint.out");

    int n, m;
    cin >> n >> m;
    for (int i = 1, x; i <= n; i++) {
        cin >> x;
        lazyUpdate(1, 1, n, i, i, x);
    }
    while (m--) {
        int x, y, z;
        cin >> x >> y >> z;
        if (x == 0) {
            cout << lazyquerry(1, 1, n, y, z) << endl;
        }
        else if (x == 1) {
            lazyUpdate(1, 1, n, y, y, z);
        }
    }
    return 0;
}