use std::io::BufRead;
use std::io::BufReader;
use std::io::Write;

fn maxim(a: usize, b: usize) -> usize {
    if a > b {a} else {b}
}

fn update(arb: &mut [usize], node: usize, left: usize, right: usize, pos: usize, val: usize) {
    if left == right { arb[node] = val; return; }
    let mid = left + (right - left) / 2;
    if pos <= mid {
        update(arb, 2 * node, left, mid, pos, val);
    } else {
        update(arb, 2 * node + 1, mid + 1, right, pos, val);
    }
    arb[node] = maxim(arb[2 * node], arb[2 * node + 1]);
}

fn query(arb: &[usize], node: usize, left: usize, right: usize, start: usize, finish: usize, max: &mut usize) {
    if start <= left && right <= finish {
        if *max < arb[node] {
            *max = arb[node];
        }
        return;
    }
    let mid = left + (right - left) / 2;
    if start <= mid {
        query(arb, 2 * node, left, mid, start, finish, max);
    }
    if right <= finish {
        query(arb, 2 * node + 1, mid + 1, right, start, finish, max);
    }
}

fn main() {
    let mut file = BufReader::new(std::fs::File::open("arbint.in").unwrap());
    let mut input = String::new();
    file.read_line(&mut input).unwrap();
    let (n, m) = input.trim().split_once(' ').unwrap();
    let n = n.parse::<usize>().unwrap();
    let m = m.parse::<usize>().unwrap();
    input.clear();
    file.read_line(&mut input).unwrap();
    let mut arb = vec![0; 4 * n + 1];
    for (i, number) in input.trim().split_whitespace().map(|s| s.parse::<usize>().unwrap()).enumerate() {
        update(&mut arb, 1, 1, n, i + 1, number);
    }
    let mut out = std::fs::File::create("arbint.out").unwrap();
    for _i in 0..m {
        input.clear();
        file.read_line(&mut input).unwrap();
        let mut iter = input.split_whitespace();
        let x = iter.next().unwrap();
        let a = iter.next().unwrap();
        let b = iter.next().unwrap();
        let x = x.parse::<usize>().unwrap();
        let a = a.parse::<usize>().unwrap();
        let b = b.parse::<usize>().unwrap();
        if x == 0 {
            let mut max = 0;
            query(&arb, 1, 1, n, a, b, &mut max);
            writeln!(out, "{}", max).unwrap();
        } else {
            update(&mut arb, 1, 1, n, a, b);
        }
    }
}