use std::io::{BufWriter,Write};
use std::fs::{self,File};

macro_rules! parse_line {
    ($iter: expr, $($t: ty),+) => {{
        let line = $iter.next().unwrap();
        let mut parts = line.split_whitespace();
        ($(parts.next().unwrap().parse::<$t>().unwrap()), +)
    }};
}
macro_rules! parse_vector {
    ($iter: expr, $t: ty) => {{
        $iter
            .next()
            .unwrap()
            .split_whitespace()
            .map(|x| x.parse::<$t>().unwrap())
            .collect::<Vec<$t>>()
    }};
}
struct SegmentTree
{
    aint : Vec<i32>
}
impl SegmentTree {
    fn new(size : usize) -> Self {
        SegmentTree { aint: (vec![0; 4 * size+1]) }
    }
    fn build(& mut self, vect: &[i32], nod: usize, st: usize, dr: usize) {
        if st == dr {
            self.aint[nod] = vect[st-1];
            return;
        }
        let mij = (st + dr)/2;
        self.build(vect, 2*nod, st, mij);
        self.build(vect, 2*nod+1, mij+1, dr);
        self.aint[nod]=std::cmp::max(self.aint[2*nod],self.aint[2*nod+1]);
    }
    fn query(& self, nod: usize, st: usize, dr: usize, ql: usize, qr: usize)->i32 {
        if ql <= st && dr <= qr {
            return self.aint[nod];
        }
        let mij = (st + dr)/2;
        let mut mini = i32::MIN;
        if ql <= mij {
            mini = std::cmp::max(mini,self.query(2*nod, st, mij, ql, qr));
        }
        if qr > mij {
            mini = std::cmp::max(mini,self.query(2*nod+1, mij+1, dr, ql, qr));
        }
        mini
    }
    fn update(&mut self, nod: usize, st: usize, dr: usize, poz: usize, val: i32) {
        if st == dr {
            self.aint[nod]=val;
            return;
        }
        let mij = (st + dr)/2;
        if poz <= mij {
        self.update(2*nod, st, mij, poz, val);
        }
        else {
            self.update(2*nod+1, mij+1, dr, poz, val);
        }
        self.aint[nod] = std::cmp::max(self.aint[2*nod],self.aint[2*nod+1]);
    }
}
fn main()->std::io::Result<()> {
    let content = fs::read_to_string("arbint.in")?;
    let mut lines = content.lines();
    let mut writer = BufWriter::new(File::create("arbint.out")?);
    let (n, m) = parse_line!(lines, usize, usize);
    let vect = parse_vector!(lines, i32);
    let mut myaint = SegmentTree::new(n);
    myaint.build(&vect, 1, 1, n);
    for _ in 0..m {
        let (op, a, b) = parse_line!(lines, usize, usize, i32);
        match op {
            0 => {
                //query pe max a b
                writeln!(writer,"{}",myaint.query(1,1,n,a,b as usize))?;
            }
            _ => {
                myaint.update(1, 1, n, a, b);
                //update pe poz a cu b
            }
        }
    }
    Ok(())
}