use std::fs::File;
use std::io::{*};
use std::cmp::max;

struct SegmentTree {
    data : Vec<i32>,
    offset : usize,
}

impl SegmentTree {
    fn new(init_data : &Vec<i32>) -> SegmentTree {
        let mut offset : usize = 1;
        while offset < init_data.len() {
            offset = 2 * offset;
        }

        let mut new_data : Vec<i32> = vec![0; 2 * offset + 1];
        for i in 0..init_data.len() {
            new_data[i + offset] = init_data[i];
        }

        for i in (1..offset).rev() {
            new_data[i] = max(new_data[i * 2], new_data[i * 2 + 1]);
        }

        SegmentTree {
            data: new_data,
            offset : offset
        }
    }

    fn get_max_h(self : &mut SegmentTree, node : usize, l : usize, r : usize, gl : usize, gr : usize) -> i32 {
        if gl <= l && r <= gr {
            return self.data[node];
        }

        if r < gl || gr < l {
            return 0;
        }

        let mid : usize = (l + r) >> 1;
        let candidate1 : i32 = self.get_max_h(node * 2, l, mid, gl, gr);
        let candidate2 : i32 = self.get_max_h(node * 2 + 1, mid + 1, r, gl, gr);

        return max(candidate1, candidate2);
    }

    fn set_data(self : &mut SegmentTree, ind : usize, number : i32) {
        let mut index : usize = ind + self.offset;
        self.data[index] = number;
        while index > 1 {
            index = index >> 1;
            self.data[index] = max(self.data[index  * 2], self.data[index * 2 + 1]);
        }
    }

    fn get_max(self : &mut SegmentTree, l : usize, r : usize) -> i32 {
        return self.get_max_h(1, 0, self.offset - 1, l, r);
    }
}

fn main() {
    let mut input = BufReader::new(File::open("arbint.in").unwrap());
    let mut output = BufWriter::new(File::create("arbint.out").unwrap());

    let mut line = String::new();
    input.read_line(&mut line).unwrap();

    let arg : Vec<usize> = line.trim().split(" ").map(|x| x.parse().unwrap()).collect();
    let (_n, m) = (arg[0], arg[1]);

    let mut line = String::new();
    input.read_line(&mut line).unwrap();

    let arg : Vec<i32> = line.trim().split(" ").map(|x| x.parse().unwrap()).collect();
    let mut st : SegmentTree = SegmentTree::new(&arg);

    for _query in 0..m {
        let mut line = String::new();
        input.read_line(&mut line).unwrap();

        let arg : Vec<usize> = line.trim().split(" ").map(|x| x.parse().unwrap()).collect();
        let op = arg[0];

        if op == 0 {
            let (lft, rht) = (arg[1], arg[2]);
            writeln!(output, "{}", st.get_max(lft - 1, rht - 1)).unwrap();
        }
        if op == 1 {
            let (ind, num) = (arg[1], arg[2]);
            st.set_data(ind - 1, num as i32);
        }
    }
}