#include <fstream>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <climits>
using namespace std;

ifstream fin("arbint.in");
ofstream fout("arbint.out");

struct tree {
    int int_left;
    int int_right;
    int max_value;
    struct tree* tree_left;
    struct tree* tree_right;
};

struct tree* generate_tree(int* A, int left_i, int right_i) {
    tree* int_tree =(tree *) calloc(1, sizeof(tree));

    int_tree->int_left = left_i;
    int_tree->int_right = right_i;

    if(left_i < right_i) {
        int mid = (right_i - left_i) / 2 + left_i;

        int_tree->tree_left = generate_tree(A, left_i, mid);
        int_tree->tree_right = generate_tree(A, mid + 1, right_i);
        int_tree->max_value = max(int_tree->tree_right->max_value, int_tree->tree_left->max_value);

    } else {
        int_tree->max_value = A[int_tree->int_left];
    }

    return int_tree;
}

void update_tree(int pos, int* A, tree * int_tree) {
    if(int_tree -> int_left == int_tree -> int_right) {
        int_tree->max_value = A[pos];
        return;
    } else {
        int mid = (int_tree -> int_right - int_tree -> int_left) / 2 + int_tree -> int_left;
        if(pos <= mid) {
            update_tree(pos, A, int_tree->tree_left);
        } else {
            update_tree(pos, A, int_tree->tree_right);
        }

        int_tree->max_value = max(int_tree->tree_right->max_value, int_tree->tree_left->max_value);
    }
}

int query_tree(tree* int_tree, int left_i, int right_i) {
    if(int_tree->int_left == left_i && int_tree->int_right == right_i) {
        return int_tree->max_value;
    } else {
        int mid = (int_tree->int_right - int_tree->int_left) / 2 + int_tree->int_left;
        int max_val = INT_MIN;
        if(left_i <= mid) {
            max_val = query_tree(int_tree->tree_left, left_i, mid);
        }
        if(right_i > mid) {
            max_val = max(max_val, query_tree(int_tree->tree_right, mid + 1, right_i));
        }

        return max_val;
    }
}

void free_tree(tree * int_tree) {
    if(int_tree == NULL)
        return;

    free_tree(int_tree->tree_left);
    free_tree(int_tree->tree_right);

    free(int_tree);
}

int main()
{
    int n, m;
    int *A;
    int type, int_left, int_right;
    tree * int_tree;

    fin >> n >> m;

    A = (int *) malloc(n * sizeof(int));

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

    int_tree = generate_tree(A, 0, n - 1);

    for(int i = 0; i < m; i++) {
        fin >> type >> int_left >> int_right;

        if(type == 0) {
            fout << query_tree(int_tree, int_left - 1, int_right - 1) << endl;
        } else if(type == 1) {
            A[int_left - 1] = int_right;
            update_tree(int_left - 1, A, int_tree);
        }
    }

    free_tree(int_tree);
    free(A);
    fin.close();
    fout.close();
    return 0;
}