use std::cmp::{max, min};
use std::io::{BufWriter, Write};
use std::{fs, fs::File};
struct Scanner<'a>(Box<Iterator<Item = &'a str> + 'a>);
impl<'a> Scanner<'a> {
    fn new(string: &'a str) -> Scanner<'a> {
        let iter = string.lines().flat_map(|x| x.split(' '));
        Scanner(Box::new(iter))
    }
    fn next<T: std::str::FromStr>(&mut self) -> T {
        match self.0.next().expect("Not enough input").parse() {
            Ok(res) => res,
            Err(_) => panic!("Parse error"),
        }
    }
}

struct SegTree {
    data: Vec<usize>,
    len: usize,
}
impl SegTree {
    fn _build<I: Iterator<Item = usize>>(
        &mut self,
        node: usize,
        b: usize,
        e: usize,
        iter: &mut I,
    ) -> usize {
        self.data[node] = match b == e {
            true => iter.next().expect("Not enough elements"),
            false => {
                let m = (b + e) / 2;
                max(
                    self._build(node * 2, b, m, iter),
                    self._build(node * 2 + 1, m + 1, e, iter),
                )
            }
        };
        self.data[node]
    }
    fn _update(&mut self, node: usize, b: usize, e: usize, pos: usize, val: usize) {
        if b == e {
            assert_eq!(b, pos);
            self.data[node] = val;
        } else {
            let m = (b + e) / 2;
            if pos <= m {
                self._update(node * 2, b, m, pos, val);
            } else {
                self._update(node * 2 + 1, m + 1, e, pos, val);
            }
            self.data[node] = max(self.data[node * 2], self.data[node * 2 + 1])
        }
    }
    fn _query(&self, node: usize, b: usize, e: usize, l: usize, r: usize) -> usize {
        let l = max(l, b);
        let r = min(r, e);
        match (l > r, (l == r && b == e)) {
            (true, _) => 0,
            (_, true) => self.data[node],
            (false, false) => {
                let m = (b + e) / 2;
                max(
                    self._query(node * 2, b, m, l, r),
                    self._query(node * 2 + 1, m + 1, e, l, r),
                )
            }
        }
    }
    fn build<I: Iterator<Item = usize>>(mut iter: I, len: usize) -> SegTree {
        let mut st = SegTree {
            data: vec![0; 4 * len],
            len,
        };
        st._build(1, 0, len - 1, &mut iter);
        st
    }
    fn update(&mut self, pos: usize, val: usize) {
        let len = self.len;
        self._update(1, 0, len - 1, pos, val);
    }
    fn query(&self, l: usize, r: usize) -> usize {
        let len = self.len;
        self._query(1, 0, len - 1, l, r)
    }
}

fn main() {
    let input = fs::read_to_string("arbint.in").expect("Read error");
    let mut writer = BufWriter::new(File::create("arbint.out").expect("Create error"));
    let mut scanner = Scanner::new(&input);

    let n: usize = scanner.next();
    let m: usize = scanner.next();
    let mut st = SegTree::build((0..n).map(|_| scanner.next::<usize>()), n);
    for _ in 0..m {
        let t: usize = scanner.next();
        let a: usize = scanner.next();
        let b: usize = scanner.next();
        match t {
            0 => {
                writer
                    .write(format!("{}\n", st.query(a - 1, b - 1)).as_bytes())
                    .expect("Write error");
            }
            1 => st.update(a - 1, b - 1),
            _ => panic!("Unexpected type"),
        }
    }
}