use proconio::{input, marker::Usize1, fastout};

// 2e5に収まるなら3、そうでないなら4。4だと手元で実行できないので注意
const TREELEVEL: usize = 4;
#[derive(Clone, Debug)]
pub struct Predecessor64{
    d: [[u64; 1<<18]; TREELEVEL],
}

impl Predecessor64 {
    pub fn new()->Self{
        Predecessor64{
            d: [[0; 1<<18]; TREELEVEL],
        }
    }

    #[inline(always)]
    pub fn is_empty(&self) -> bool {
        self.d[TREELEVEL-1][0]==0
    }

    #[inline(always)]
    pub fn include(&self, p: usize) -> bool {
        self.d[0][p>>6]&1<<(p&63)!=0
    }

    #[inline(always)]
    pub fn insert(&mut self, p: usize){
        for i in 0..TREELEVEL{
            if self.d[i][p>>(6*(i+1))]&1<<((p>>(6*i))&63)==0{
                self.d[i][p>>(6*(i+1))] |= 1<<((p>>(6*i))&63);
            } else {
                return;
            }
        }
    }

    #[inline(always)]
    pub fn remove(&mut self, p: usize){
        if self.d[0][p>>6]&1<<(p&63)==0{return;}
        for i in 0..TREELEVEL{
            self.d[i][p>>(6*(i+1))] ^= 1<<((p>>(6*i))&63);
            if self.d[i][p>>(6*(i+1))]!=0{
                return;
            } 
        }
    }

    #[inline(always)]
    fn ml(r: usize)->u64{
        (1<<r)-1
    }

    #[inline(always)]
    fn mr(l: usize)->u64{
        if l==63{return 0;}
        !((1<<(l+1))-1)
    }

    #[inline(always)]
    fn msb(bit: u64)->usize{
        63-bit.leading_zeros()as usize
    }

    #[inline(always)]
    fn lsb(bit: u64)->usize{
        bit.trailing_zeros()as usize
    }

    //存在しないは!0
    #[inline(always)]
    pub fn prev(&self, mut p: usize)->usize{
        for i in 0..TREELEVEL{
            if Self::ml(p&63)&self.d[i][p>>6]!=0{
                let mut res = ((p>>6)<<6)|Self::msb(self.d[i][p>>6]&Self::ml(p&63));
                for j in (0..i).rev(){
                    res = (res<<6)|Self::msb(self.d[j][res]);
                }
                return res;
            }
            p >>= 6;
        }
        !0
    }

    #[inline(always)]
    pub fn next(&self, mut p: usize)->usize{
        for i in 0..TREELEVEL{
            if Self::mr(p&63)&self.d[i][p>>6]!=0{
                let mut res = ((p>>6)<<6)|Self::lsb(self.d[i][p>>6]&Self::mr(p&63));
                for j in (0..i).rev(){
                    res = (res<<6)|Self::lsb(self.d[j][res]);
                }
                return res;
            }
            p >>= 6;
        }
        !0
    }

    #[inline(always)]
    pub fn inprev(&self, p: usize)->usize{
        if self.include(p){p}
        else {self.prev(p)}
    }

    #[inline(always)]
    pub fn innext(&self, p: usize)->usize{
        if self.include(p){p}
        else {self.next(p)}
    }

    #[inline(always)]
    pub fn min(&self)->usize{
        self.innext(0)
    }

    #[inline(always)]
    pub fn max(&self)->usize{
        self.inprev((1<<TREELEVEL)-1)
    }
}

#[inline(always)]
fn remove(x: i32, fr1: &mut [i32], fr2: &mut [i32], c: &mut Predecessor64, re: &mut Predecessor64){
    let x = x as usize;
    fr1[x] -= 1;
    if fr1[x]==0{
        c.remove(x);
        let r = c.next(x);
        let l = c.prev(x);
        if l==!0{
            if r < 1<<20{
                fr2[x^r] -= 1;
                if fr2[x^r]==0{
                    re.remove(x^r);
                }
            } 
        } else if r < 1<<20{
            if fr2[l^r]==0{
                re.insert(l^r);
            }
            fr2[l^r] += 1;
            fr2[l^x] -= 1;
            if fr2[l^x]==0{
                re.remove(l^x);
            }
            fr2[r^x] -= 1;
            if fr2[r^x]==0{
                re.remove(r^x);
            }
        } else {
            fr2[l^x] -= 1;
            if fr2[l^x] == 0{
                re.remove(l^x);
            }
        }
    } else {
        fr2[0] -= 1;
        if fr2[0]==0{
            re.remove(0);
        }
    }
}

#[inline(always)]
fn insert(x: i32, fr1: &mut [i32], fr2: &mut [i32], c: &mut Predecessor64, re: &mut Predecessor64){
    let x = x as usize;
    if fr1[x]==0{
        let r = c.next(x);
        let l = c.prev(x);
        if l==!0{
            if r < 1<<20{
                if fr2[x^r]==0{
                    re.insert(x^r);
                }
                fr2[x^r] += 1;
            } 
        } else if r < 1<<20{
            fr2[l^r] -= 1;
            if fr2[l^r]==0{
                re.remove(l^r);
            }
            if fr2[l^x]==0{
                re.insert(l^x);
            }
            fr2[l^x] += 1;
            if fr2[r^x]==0{
                re.insert(r^x);
            }
            fr2[r^x] += 1;
        } else {
            if fr2[l^x] == 0{
                re.insert(l^x);
            }
            fr2[l^x] += 1;
        }
        c.insert(x);
    } else {
        if fr2[0]==0{
            re.insert(0);
        }
        fr2[0] += 1;
    }
    fr1[x] += 1;
}

const ROT_DELTA: [u32; 4] = [3, 0, 0, 1];
#[inline]
pub fn hilbert_order(x: u32, y: u32, pow: u32, rot: u32) -> u64 {
    if pow == 0 { return 0; }
    let h: u32 = 1u32 << (pow - 1);
    let mut seg: u32 = if x < h {if y < h { 0 } else { 3 }} else {if y < h { 1 } else { 2 }};
    seg = (seg + rot) & 3;
    let nrot = (rot + ROT_DELTA[seg as usize]) & 3;
    let nx = x & (h - 1);
    let ny = y & (h - 1);
    let sub: u64 = 1u64 << (2 * pow - 2);
    let mut ord = (seg as u64) * sub;
    let add = hilbert_order(nx, ny, pow - 1, nrot);
    ord += if seg == 1 || seg == 2 { add } else { sub - 1 - add };
    ord
}

const MULTI: bool = false;
#[fastout]
fn solve(){
    input!{
        n: usize, q: usize,
        mut a: [i32; n],
    }
    let mut pre = a.clone();
    let mut query = vec![(!0, -1, -1); q];
    let mut qs = Vec::new();
    for i in 0..q{
        input!{
            t: u8,
        }
        if t==1 {
            input!{
                p: Usize1, x: i32,
            }
            query[i] = (p, pre[p], x);
            pre[p] = x;
        } else {
            input!{
                r: usize,
            }
            qs.push((r, i));
        }
    }
    let ord_x = (0..qs.len()).into_iter().map(|i| {let (x,y)=qs[i];hilbert_order(x as u32, y as u32, 18, 0)}).collect::<Vec<_>>();
    let mut ord = (0..qs.len()).collect::<Vec<_>>();
    ord.sort_unstable_by_key(|&idx| ord_x[idx]);
    let mut ans = vec![0; qs.len()];
    let mut cnt = Predecessor64::new();
    let mut res = Predecessor64::new();
    let mut fr1 = vec![0; 1<<20];
    let mut fr2 = vec![0; 1<<21];
    let (mut l, mut r) = (0, 0);
    for idx in ord{
        let (left, right) = (qs[idx].0, qs[idx].1);
        while r < right{
            if query[r].0!=!0{
                let (p, u, v) = query[r];
                a[p] = v;
                if p < l{
                    remove(u, &mut fr1, &mut fr2, &mut cnt, &mut res);              
                    insert(v, &mut fr1, &mut fr2, &mut cnt, &mut res);
                }
            }
            r += 1;
        }
        while l > left{
            l -= 1;
            remove(a[l], &mut fr1, &mut fr2, &mut cnt, &mut res);
        }
        while r > right{
            r -= 1;
            if query[r].0!=!0{
                let (p, u, v) = query[r];
                a[p] = u;
                if p < l{
                    remove(v, &mut fr1, &mut fr2, &mut cnt, &mut res);
                    insert(u, &mut fr1, &mut fr2, &mut cnt, &mut res);
                }
            }
        }
        while l < left{
            insert(a[l], &mut fr1, &mut fr2, &mut cnt, &mut res);
            l += 1;
        }
        ans[idx] = res.min();
    }
    for x in ans{
        println!("{}", x);
    }
}

//#[fastout]
fn main() {
    if MULTI{
        input!{
            t: usize,
        }
        for _ in 0..t{
            solve();
        }
    } else {
        solve();
    }
}