Problem:
Score : 500 points

Problem Statement

We have N bulbs arranged on a number line, numbered 1 to N from left to right.
Bulb i is at coordinate i.

Each bulb has a non-negative integer parameter called intensity.
When there is a bulb of intensity d at coordinate x, the bulb illuminates the segment from coordinate x-d-0.5 to x+d+0.5.
Initially, the intensity of Bulb i is A_i. We will now do the following operation K times in a row:

For each integer i between 1 and N (inclusive), let B_i be the number of bulbs illuminating coordinate i. Then, change the intensity of each bulb i to B_i.

Find the intensity of each bulb after the K operations.

Constraints

1 \leq N \leq 2 \times 10^5

1 \leq K \leq 2 \times 10^5

0 \leq A_i \leq N

Input

Input is given from Standard Input in the following format:

N K
A_1 A_2 \ldots A_N

Output

Print the intensity A{'}_i of each bulb i after the K operations to Standard Output in the following format:

A{'}_1 A{'}_2 \ldots A{'}_N

Sample Input 1

5 1
1 0 0 1 0

Sample Output 1

1 2 2 1 2

Initially, only Bulb 1 illuminates coordinate 1, so the intensity of Bulb 1 becomes 1 after the operation.
Similarly, the bulbs initially illuminating coordinate 2 are Bulb 1 and 2, so the intensity of Bulb 2 becomes 2.

Sample Input 2

5 2
1 0 0 1 0

Sample Output 2

3 3 4 4 3

Solution in Rust (1.42.0) (judge verdict: Time Limit Exceeded)

#![allow(unused_imports, non_snake_case)]
#![allow(dead_code)]
use crate::scanner::Scanner;
use crate::{data_structure::segment_tree::SegRangeAdd, ext::iter::IterExtra, misc::join};
use maplit::*;
fn main() {
    let mut scan = Scanner::new();
    let n = scan.read::<i32>();
    let k = scan.read::<i32>();
    let a = scan.readn::<i64>(n);
    let mut prev = SegRangeAdd::new(a.clone());
    let mut cur = SegRangeAdd::new(a);
    for _ in 0..k {
        if cur.sum(0..n) == n as i64 * n as i64 {
            break;
        }
        std::mem::swap(&mut prev, &mut cur);
        cur = SegRangeAdd::new(list ! ( 0 ; n ));
        for j in 0..n {
            let p = prev.sum(j..=j);
            cur.add(j - p as i32..=j + p as i32, 1);
        }
    }
    let ret = (0..n).map(|i| cur.sum(i..=i)).to_list();
    println!("{}", join(&ret, " "));
}
pub mod ext {
    pub mod range {
        use crate::independent::integer::Int;
        use std::cmp::{max, min};
        use std::ops::{Bound, Range, RangeBounds, RangeInclusive};
        pub trait RangeEx<T> {
            fn width(&self) -> T;
            fn empty(&self) -> bool;
            fn contain_range(&self, inner: &Self) -> bool;
            fn separate_range(&self, other: &Self) -> bool;
            type ReturnRange;
            fn overlap(&self, other: &Self) -> Self::ReturnRange;
        }
        impl<T: Int> RangeEx<T> for Range<T> {
            fn width(&self) -> T {
                if self.empty() {
                    T::zero()
                } else {
                    self.end - self.start
                }
            }
            fn empty(&self) -> bool {
                !(self.start < self.end)
            }
            fn contain_range(&self, inner: &Self) -> bool {
                self.start <= inner.start && inner.end <= self.end
            }
            fn separate_range(&self, other: &Self) -> bool {
                self.end <= other.start || other.end <= self.start
            }
            type ReturnRange = Range<T>;
            fn overlap(&self, other: &Self) -> Self::ReturnRange {
                let left = max(self.start, other.start);
                let right = min(self.end, other.end);
                left..right
            }
        }
        impl<T: Int> RangeEx<T> for RangeInclusive<T> {
            fn width(&self) -> T {
                if self.empty() {
                    T::zero()
                } else {
                    *self.end() - *self.start() + T::one()
                }
            }
            fn empty(&self) -> bool {
                !(self.start() <= self.end())
            }
            fn contain_range(&self, inner: &Self) -> bool {
                self.start() <= inner.start() && inner.end() <= self.end()
            }
            fn separate_range(&self, other: &Self) -> bool {
                self.end() <= other.start() || other.end() <= self.start()
            }
            type ReturnRange = RangeInclusive<T>;
            fn overlap(&self, other: &Self) -> Self::ReturnRange {
                let left = *max(self.start(), other.start());
                let right = *min(self.end(), other.end());
                left..=right
            }
        }
        pub trait IntRangeBounds<U: Int>: RangeBounds<U> {
            #[doc = " inclusive"]
            fn lower_bound(&self, lower_bound: U) -> U {
                match self.start_bound() {
                    Bound::Included(x) => max(lower_bound, *x),
                    Bound::Excluded(x) => max(lower_bound, *x + U::one()),
                    Bound::Unbounded => lower_bound,
                }
            }
            #[doc = " exclusive"]
            fn upper_bound(&self, upper_bound: U) -> U {
                match self.end_bound() {
                    Bound::Included(x) => min(upper_bound, *x + U::one()),
                    Bound::Excluded(x) => min(upper_bound, *x),
                    Bound::Unbounded => upper_bound,
                }
            }
            fn to_range(&self, lb: U, ub: U) -> Range<U> {
                self.lower_bound(lb)..self.upper_bound(ub)
            }
        }
        impl<T: ?Sized, U: Int> IntRangeBounds<U> for T where T: RangeBounds<U> {}
    }
    pub mod iter {
        use crate::arraylist::List;
        pub trait IterExtra: Iterator {
            fn to_list(self) -> List<Self::Item>
            where
                Self: Sized,
            {
                self.collect()
            }
            fn icount(self) -> i32
            where
                Self: Sized,
            {
                self.count() as i32
            }
            fn ienumerate(
                self,
            ) -> std::iter::Map<
                std::iter::Enumerate<Self>,
                fn((usize, Self::Item)) -> (i32, Self::Item),
            >
            where
                Self: Sized,
            {
                self.enumerate().map(|t| (t.0 as i32, t.1))
            }
        }
        impl<T: ?Sized> IterExtra for T where T: Iterator {}
    }
}
pub mod scanner {
    use crate::arraylist::List;
    use std::io::{stdin, BufReader, Bytes, Read, Stdin};
    use std::str::FromStr;
    pub struct Scanner {
        buf: Bytes<BufReader<Stdin>>,
    }
    impl Scanner {
        pub fn new() -> Scanner {
            Scanner {
                buf: BufReader::new(stdin()).bytes(),
            }
        }
        pub fn read_next<T: FromStr>(&mut self) -> Option<T> {
            let token = self
                .buf
                .by_ref()
                .map(|c| c.unwrap() as char)
                .skip_while(|c| c.is_whitespace())
                .take_while(|c| !c.is_whitespace())
                .collect::<String>();
            token.parse::<T>().ok()
        }
        pub fn read<T: FromStr>(&mut self) -> T {
            self.read_next().unwrap()
        }
        pub fn readn<T: FromStr>(&mut self, n: i32) -> List<T> {
            (0..n).map(|_| self.read::<T>()).collect()
        }
        pub fn chars(&mut self) -> List<char> {
            self.read::<String>().chars().collect()
        }
    }
}
pub mod arraylist {
    use crate::{ext::range::IntRangeBounds, independent::integer::Int};
    use std::fmt::Formatter;
    use std::iter::FromIterator;
    use std::ops::{Index, IndexMut, RangeBounds};
    use std::slice::Iter;
    #[derive(Clone, PartialEq, Eq)]
    pub struct List<T> {
        pub vec: Vec<T>,
    }
    impl<T> List<T> {
        #[inline]
        pub fn new() -> List<T> {
            List { vec: vec![] }
        }
        #[inline]
        pub fn init(init: T, n: i32) -> List<T>
        where
            T: Clone,
        {
            List {
                vec: vec![init; n as usize],
            }
        }
        #[inline]
        pub fn from_vec(vec: Vec<T>) -> List<T> {
            List { vec }
        }
        #[inline]
        pub fn ilen(&self) -> i32 {
            self.vec.len() as i32
        }
        #[inline]
        pub fn iter(&self) -> Iter<'_, T> {
            self.vec.iter()
        }
        #[inline]
        pub fn push(&mut self, item: T) {
            self.vec.push(item);
        }
        #[inline]
        pub fn sort(&mut self)
        where
            T: Ord,
        {
            self.vec.sort();
        }
        #[inline]
        pub fn reverse(&mut self) {
            self.vec.reverse();
        }
        #[inline]
        pub fn sort_by<F>(&mut self, compare: F)
        where
            F: FnMut(&T, &T) -> std::cmp::Ordering,
        {
            self.vec.sort_by(compare)
        }
        #[inline]
        pub fn sort_by_key<K, F>(&mut self, compare: F)
        where
            F: FnMut(&T) -> K,
            K: Ord,
        {
            self.vec.sort_by_key(compare)
        }
        #[inline]
        pub fn first(&self) -> Option<&T> {
            self.vec.first()
        }
        #[inline]
        pub fn last(&self) -> Option<&T> {
            self.vec.last()
        }
        #[inline]
        pub fn pop(&mut self) -> Option<T> {
            self.vec.pop()
        }
        #[inline]
        pub fn swap(&mut self, i: i32, j: i32) {
            self.vec.swap(i as usize, j as usize);
        }
        #[inline]
        pub fn append(&mut self, mut other: Self) {
            self.vec.append(&mut other.vec);
        }
        #[inline]
        pub fn extend(&mut self, other: impl Iterator<Item = T>) {
            self.vec.extend(other);
        }
        #[inline]
        pub fn mirror(&self) -> std::iter::Cloned<Iter<T>>
        where
            T: Clone,
        {
            self.iter().cloned()
        }
        #[inline]
        pub fn map<B, F>(&self, f: F) -> List<B>
        where
            T: Clone,
            F: FnMut(T) -> B,
        {
            self.mirror().map(f).collect()
        }
        #[inline]
        pub fn filter<P>(&self, predicate: P) -> List<T>
        where
            T: Clone,
            P: FnMut(&T) -> bool,
        {
            self.mirror().filter(predicate).collect()
        }
        #[inline]
        pub fn filter_map<B, F>(&self, f: F) -> List<B>
        where
            T: Clone,
            F: FnMut(T) -> Option<B>,
        {
            self.mirror().filter_map(f).collect()
        }
        #[inline]
        pub fn any<P>(&self, predicate: P) -> bool
        where
            P: FnMut(&T) -> bool,
        {
            self.iter().any(predicate)
        }
        #[inline]
        pub fn all<P>(&self, predicate: P) -> bool
        where
            P: FnMut(&T) -> bool,
        {
            self.iter().all(predicate)
        }
        #[inline]
        pub fn sum(&self) -> T
        where
            T: Int,
        {
            self.iter().cloned().fold(T::zero(), |acc, x| acc + x)
        }
        #[inline]
        pub fn enumerate(&self) -> List<(i32, T)>
        where
            T: Clone,
        {
            self.mirror()
                .enumerate()
                .map(|p| (p.0 as i32, p.1))
                .collect()
        }
        #[inline]
        pub fn find<P>(&self, mut predicate: P) -> Option<&T>
        where
            P: FnMut(&T) -> bool,
        {
            self.iter().find(|x| predicate(*x))
        }
        #[inline]
        pub fn index_of<P>(&self, mut predicate: P) -> Option<i32>
        where
            P: FnMut(&T) -> bool,
        {
            self.iter()
                .enumerate()
                .find(|&(_i, x)| predicate(x))
                .map(|p| p.0 as i32)
        }
        #[inline]
        pub fn to<B: FromIterator<T>>(&self) -> B
        where
            T: Clone,
        {
            self.mirror().collect()
        }
        #[inline]
        pub fn min(&self) -> Option<&T>
        where
            T: Ord,
        {
            self.iter().min()
        }
        #[inline]
        pub fn max(&self) -> Option<&T>
        where
            T: Ord,
        {
            self.iter().max()
        }
        #[inline]
        pub fn argmin(&self) -> Option<i32>
        where
            T: Ord,
        {
            let item = self.iter().min()?;
            self.iter()
                .enumerate()
                .find(|p| p.1 == item)
                .map(|p| p.0 as i32)
        }
        #[inline]
        pub fn argmax(&self) -> Option<i32>
        where
            T: Ord,
        {
            let item = self.iter().max()?;
            self.iter()
                .enumerate()
                .find(|p| p.1 == item)
                .map(|p| p.0 as i32)
        }
        #[inline]
        pub fn part<U>(&self, range: U) -> List<T>
        where
            T: Clone,
            U: RangeBounds<i32>,
        {
            List::from_vec(
                self.vec[range.lower_bound(0) as usize..range.upper_bound(self.ilen()) as usize]
                    .to_vec(),
            )
        }
        #[inline]
        pub fn first_exn(&self) -> &T {
            self.first().unwrap()
        }
        #[inline]
        pub fn last_exn(&self) -> &T {
            self.last().unwrap()
        }
        #[inline]
        pub fn pop_exn(&mut self) -> T {
            self.pop().unwrap()
        }
        #[inline]
        pub fn min_exn(&self) -> &T
        where
            T: Ord,
        {
            self.min().unwrap()
        }
        #[inline]
        pub fn max_exn(&self) -> &T
        where
            T: Ord,
        {
            self.max().unwrap()
        }
        #[inline]
        pub fn argmin_exn(&self) -> i32
        where
            T: Ord,
        {
            self.argmin().unwrap()
        }
        #[inline]
        pub fn argmax_exn(&self) -> i32
        where
            T: Ord,
        {
            self.argmax().unwrap()
        }
        #[inline]
        pub fn find_exn<P>(&self, predicate: P) -> &T
        where
            P: FnMut(&T) -> bool,
        {
            self.find(predicate).unwrap()
        }
        #[inline]
        pub fn index_of_exn<P>(&self, predicate: P) -> i32
        where
            P: FnMut(&T) -> bool,
        {
            self.index_of(predicate).unwrap()
        }
    }
    impl<T> Index<i32> for List<T> {
        type Output = T;
        #[inline]
        fn index(&self, index: i32) -> &Self::Output {
            if cfg!(debug_assertions) {
                self.vec.index(index as usize)
            } else {
                unsafe { self.vec.get_unchecked(index as usize) }
            }
        }
    }
    impl<T> IndexMut<i32> for List<T> {
        #[inline]
        fn index_mut(&mut self, index: i32) -> &mut Self::Output {
            if cfg!(debug_assertions) {
                self.vec.index_mut(index as usize)
            } else {
                unsafe { self.vec.get_unchecked_mut(index as usize) }
            }
        }
    }
    impl<T> FromIterator<T> for List<T> {
        fn from_iter<U: IntoIterator<Item = T>>(iter: U) -> Self {
            let mut vec = vec![];
            for i in iter {
                vec.push(i);
            }
            List { vec }
        }
    }
    impl<T> IntoIterator for List<T> {
        type Item = T;
        type IntoIter = std::vec::IntoIter<T>;
        fn into_iter(self) -> std::vec::IntoIter<T> {
            self.vec.into_iter()
        }
    }
    impl<'a, T> IntoIterator for &'a List<T> {
        type Item = &'a T;
        type IntoIter = Iter<'a, T>;
        fn into_iter(self) -> Iter<'a, T> {
            self.vec.iter()
        }
    }
    impl<T: std::fmt::Display> std::fmt::Display for List<T> {
        fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
            write!(
                f,
                "{}",
                self.iter()
                    .map(|x| format!("{}", x))
                    .collect::<Vec<_>>()
                    .join(" ")
            )
        }
    }
    impl<T: std::fmt::Debug> std::fmt::Debug for List<T> {
        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
            write!(
                f,
                "[{}]",
                self.iter()
                    .map(|x| format!("{:?}", x))
                    .collect::<Vec<_>>()
                    .join(", ")
            )
        }
    }
    impl<T> From<Vec<T>> for List<T> {
        fn from(vec: Vec<T>) -> Self {
            Self::from_vec(vec)
        }
    }
    impl<T: Clone> From<&[T]> for List<T> {
        fn from(slice: &[T]) -> Self {
            slice.iter().cloned().collect()
        }
    }
    #[macro_export]
    macro_rules ! list { ( ) => { $ crate :: arraylist :: List :: new ( ) } ; ( $ init : expr ; $ ( $ dim : expr ) ;* ) => { list ! ( $ ( $ dim ) ;* => $ init ) } ; ( $ head : expr ; $ ( $ tail : expr ) ;* => $ init : expr ) => { $ crate :: arraylist :: List :: init ( list ! ( $ ( $ tail ) ;* => $ init ) , $ head ) } ; ( $ head : expr => $ init : expr ) => { $ crate :: arraylist :: List :: init ( $ init , $ head ) } ; }
}
pub mod independent {
    pub mod integer {
        pub trait Int:
            std::ops::Add<Output = Self>
            + std::ops::Sub<Output = Self>
            + std::ops::Mul<Output = Self>
            + std::ops::Div<Output = Self>
            + std::ops::Rem<Output = Self>
            + std::hash::Hash
            + PartialEq
            + Eq
            + PartialOrd
            + Ord
            + Copy
        {
            fn to_u8(&self) -> u8;
            fn to_u16(&self) -> u16;
            fn to_u32(&self) -> u32;
            fn to_u64(&self) -> u64;
            fn to_u128(&self) -> u128;
            fn to_i8(&self) -> i8;
            fn to_i16(&self) -> i16;
            fn to_i32(&self) -> i32;
            fn to_i64(&self) -> i64;
            fn to_i128(&self) -> i128;
            fn to_usize(&self) -> usize;
            fn to_isize(&self) -> isize;
            fn zero() -> Self;
            fn one() -> Self;
        }
        macro_rules ! impl_integer_functions { ( $ ( $ name : ident , $ tpe : ident ) ,* ) => { $ ( fn $ name ( & self ) -> $ tpe { * self as $ tpe } ) * } ; }
        macro_rules ! impl_integer { ( $ ( $ tpe : ident ) ,* ) => { $ ( impl Int for $ tpe { impl_integer_functions ! ( to_u8 , u8 , to_u16 , u16 , to_u32 , u32 , to_u64 , u64 , to_u128 , u128 , to_i8 , i8 , to_i16 , i16 , to_i32 , i32 , to_i64 , i64 , to_i128 , i128 , to_usize , usize , to_isize , isize ) ; fn zero ( ) -> Self { 0 } fn one ( ) -> Self { 1 } } ) * } ; }
        impl_integer!(u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, usize, isize);
    }
}
pub mod misc {
    use crate::arraylist::List;
    use crate::independent::integer::Int;
    use std::collections::{BTreeSet, HashMap};
    pub const CONST_1E9_7: i64 = 1_000_000_007;
    pub fn rep<'a, S, T>(n: i32, mut f: S) -> List<T>
    where
        S: FnMut() -> T + 'a,
    {
        (0..n).map(|_| f()).collect::<List<T>>()
    }
    pub fn adjacent4(y: i32, x: i32, h: i32, w: i32) -> impl Iterator<Item = (i32, i32)> {
        const DYDX: [(i32, i32); 4] = [(-1, 0), (1, 0), (0, -1), (0, 1)];
        DYDX.iter().filter_map(move |&(dy, dx)| {
            let ny = y + dy;
            let nx = x + dx;
            if nx >= 0 && nx < w && ny >= 0 && ny < h {
                Some((ny, nx))
            } else {
                None
            }
        })
    }
    pub fn adjacent8(y: i32, x: i32, h: i32, w: i32) -> impl Iterator<Item = (i32, i32)> {
        const DYDX: [(i32, i32); 8] = [
            (-1, 0),
            (1, 0),
            (0, -1),
            (0, 1),
            (-1, -1),
            (-1, 1),
            (1, -1),
            (1, 1),
        ];
        DYDX.iter().filter_map(move |&(dy, dx)| {
            let ny = y + dy;
            let nx = x + dx;
            if nx >= 0 && nx < w && ny >= 0 && ny < h {
                Some((ny, nx))
            } else {
                None
            }
        })
    }
    pub fn run_length_encoding<T: Clone + PartialEq>(slice: &List<T>) -> List<(i64, T)> {
        slice.mirror().fold(List::new(), |mut acc, x| {
            if let Some((cnt, item)) = acc.pop() {
                if item == x {
                    acc.push((cnt + 1, x));
                } else {
                    acc.push((cnt, item));
                    acc.push((1, x));
                }
            } else {
                acc.push((1, x));
            }
            acc
        })
    }
    pub fn indices_by_elem<T: Eq + std::hash::Hash + Clone>(
        slice: &List<T>,
    ) -> std::collections::HashMap<T, List<i32>> {
        let mut hmap = std::collections::HashMap::new();
        for i in 0..slice.ilen() {
            hmap.entry(slice[i].clone()).or_insert(List::new()).push(i);
        }
        hmap
    }
    pub fn combine<S: Clone, T: Clone, U: std::iter::FromIterator<(S, T)>>(
        left: &[S],
        right: &[T],
    ) -> U {
        let mut ret = vec![];
        for i in 0..left.len() {
            for j in 0..right.len() {
                ret.push((left[i].clone(), right[j].clone()));
            }
        }
        ret.into_iter().collect::<U>()
    }
    pub fn split<T: PartialEq + Clone>(slice: &List<T>, sep: T) -> List<List<T>> {
        slice
            .iter()
            .fold(List::from(vec![List::new()]), |mut acc, x| {
                if x == &sep {
                    acc.push(List::new());
                    acc
                } else {
                    let last = acc.ilen() - 1;
                    acc[last].push(x.clone());
                    acc
                }
            })
    }
    pub fn join<T: std::fmt::Display>(slice: &List<T>, sep: &str) -> String {
        let strings = slice.iter().map(|t| format!("{}", t)).collect::<Vec<_>>();
        strings.join(sep)
    }
    pub fn coord_comp(slice: &List<i64>) -> (List<i64>, HashMap<i64, i32>) {
        let mut set = BTreeSet::new();
        for &item in slice {
            set.insert(item);
        }
        let mut hmap = HashMap::new();
        for (i, &v) in set.iter().enumerate() {
            hmap.insert(v, i as i32);
        }
        (set.into_iter().collect::<List<_>>(), hmap)
    }
    pub fn shakutori(n: i32, k: i64, a: &List<i64>) -> i32 {
        let mut sum = 0;
        let mut right = 0;
        let mut ret = 0;
        for left in 0..n {
            while right < n && sum <= k {
                sum += a[right];
                right += 1;
            }
            ret += right - left;
            if right == left {
                right += 1;
            } else {
                sum -= a[left];
            }
        }
        ret
    }
    pub fn inverse(a: &List<i32>, n: i32) -> List<i32> {
        let mut inv = List::init(0, n);
        for i in 0..a.ilen() {
            inv[a[i]] = i;
        }
        inv
    }
    pub fn pow(mut a: i64, mut n: i64) -> i64 {
        let mut res = 1;
        while n > 0 {
            if n & 1 == 1 {
                res *= a;
            }
            a = a * a;
            n >>= 1;
        }
        res
    }
    pub fn ceil_div<T: Int>(x: T, y: T) -> T {
        (x + y - T::one()) / y
    }
    pub fn ceil_mod<T: Int>(x: T, y: T) -> T {
        ceil_div(x, y) * y
    }
    pub fn unzip<P: Clone, Q: Clone>(v: &List<(P, Q)>) -> (List<P>, List<Q>) {
        (
            v.iter().map(|t| t.0.clone()).collect(),
            v.iter().map(|t| t.1.clone()).collect(),
        )
    }
    pub fn unzip3<P: Clone, Q: Clone, R: Clone>(
        v: &List<(P, Q, R)>,
    ) -> (List<P>, List<Q>, List<R>) {
        (
            v.iter().map(|t| t.0.clone()).collect(),
            v.iter().map(|t| t.1.clone()).collect(),
            v.iter().map(|t| t.2.clone()).collect(),
        )
    }
    pub fn is_palindrome<T: Clone + Eq>(chars: &List<T>) -> bool {
        let s = chars.clone();
        let mut t = s.clone();
        t.reverse();
        (0..s.ilen()).filter(|&i| s[i] == t[i]).count() as i32 == s.ilen()
    }
}
pub mod data_structure {
    pub mod segment_tree {
        use crate::arraylist::List;
        use crate::ext::range::{IntRangeBounds, RangeEx};
        use std::ops::{Range, RangeBounds};
        pub struct SegTree<'a> {
            node: List<i64>,
            op: Box<dyn Fn(i64, i64) -> i64 + 'a>,
            zero: i64,
            n: i32,
        }
        impl<'a> SegTree<'a> {
            pub fn new<B>(v: List<i64>, zero: i64, op: B) -> SegTree<'a>
            where
                B: Fn(i64, i64) -> i64 + 'a,
            {
                let size = v.ilen();
                let mut n = 1i32;
                while n < size {
                    n *= 2
                }
                let mut node = List::init(zero, 2 * n - 1);
                for i in 0..size {
                    node[i + n - 1] = v[i]
                }
                for i in (0..n - 1).rev() {
                    node[i] = op(node[2 * i + 1], node[2 * i + 2])
                }
                SegTree {
                    node,
                    op: Box::new(op),
                    zero,
                    n,
                }
            }
            pub fn set(&mut self, mut x: i32, value: i64) {
                x += self.n - 1;
                self.node[x] = value;
                while x > 0 {
                    x = (x - 1) / 2;
                    self.node[x] = (self.op)(self.node[2 * x + 1], self.node[2 * x + 2]);
                }
            }
            pub fn get1(&self, i: i32) -> i64 {
                self.getrec(i..i + 1, 0, 0..self.n)
            }
            pub fn get<T>(&self, query: T) -> i64
            where
                T: RangeBounds<i32>,
            {
                self.getrec(query.to_range(0, self.n), 0, 0..self.n)
            }
            fn getrec(&self, query: Range<i32>, k: i32, range: Range<i32>) -> i64 {
                if query.separate_range(&range) {
                    return self.zero;
                }
                if query.contain_range(&range) {
                    return self.node[k];
                }
                let vl = self.getrec(
                    query.clone(),
                    2 * k + 1,
                    range.start..(range.start + range.end) / 2,
                );
                let vr = self.getrec(
                    query.clone(),
                    2 * k + 2,
                    (range.start + range.end) / 2..range.end,
                );
                (self.op)(vl, vr)
            }
        }
        pub struct DualSegTree<'a> {
            node: List<i64>,
            op: Box<dyn Fn(i64, i64) -> i64 + 'a>,
            n: i32,
        }
        impl<'a> DualSegTree<'a> {
            pub fn new<B>(v: List<i64>, zero: i64, op: B) -> DualSegTree<'a>
            where
                B: Fn(i64, i64) -> i64 + 'a,
            {
                let size = v.ilen();
                let mut n = 1i32;
                while n < size {
                    n *= 2
                }
                let mut node = List::init(zero, 2 * n - 1);
                for i in 0..size {
                    node[i + n - 1] = v[i]
                }
                for i in (0..n - 1).rev() {
                    node[i] = op(node[2 * i + 1], node[2 * i + 2])
                }
                DualSegTree {
                    node,
                    op: Box::new(op),
                    n,
                }
            }
            pub fn get(&self, mut x: i32) -> i64 {
                x += self.n - 1;
                let mut ret = self.node[x];
                while x > 0 {
                    x = (x - 1) / 2;
                    ret = (self.op)(ret, self.node[x]);
                }
                ret
            }
            pub fn set<T>(&mut self, query: T, value: i64)
            where
                T: RangeBounds<i32>,
            {
                let n = self.n;
                self.setrec(query.to_range(0, n), 0, 0..n, value);
            }
            fn setrec(&mut self, query: Range<i32>, k: i32, range: Range<i32>, value: i64) {
                if query.separate_range(&range) {
                    return;
                }
                if query.contain_range(&range) {
                    self.node[k] = (self.op)(self.node[k], value);
                    return;
                }
                self.setrec(
                    query.clone(),
                    2 * k + 1,
                    range.start..(range.start + range.end) / 2,
                    value,
                );
                self.setrec(
                    query.clone(),
                    2 * k + 2,
                    (range.start + range.end) / 2..range.end,
                    value,
                );
            }
        }
        pub struct SegRangeAdd {
            node: List<i64>,
            lazy: List<i64>,
            n: i32,
        }
        impl SegRangeAdd {
            pub fn new(v: List<i64>) -> SegRangeAdd {
                let size = v.ilen();
                let mut n = 1;
                while n < size {
                    n *= 2
                }
                let mut node = List::init(0, 2 * n - 1);
                let lazy = List::init(0, 2 * n - 1);
                for i in 0..size {
                    node[i + n - 1] = v[i]
                }
                for i in (0..n - 1).rev() {
                    node[i] = node[i * 2 + 1] + node[i * 2 + 2]
                }
                SegRangeAdd { node, lazy, n }
            }
            fn eval(&mut self, k: i32, range: Range<i32>) {
                if self.lazy[k] != 0 {
                    self.node[k] += self.lazy[k];
                    if range.width() > 1 {
                        self.lazy[2 * k + 1] += self.lazy[k] / 2;
                        self.lazy[2 * k + 2] += self.lazy[k] / 2;
                    }
                    self.lazy[k] = 0;
                }
            }
            pub fn add<T>(&mut self, query: T, x: i64)
            where
                T: RangeBounds<i32>,
            {
                let n = self.n;
                self.addrec(query.to_range(0, n), x, 0, 0..n)
            }
            fn addrec(&mut self, query: Range<i32>, x: i64, k: i32, range: Range<i32>) {
                self.eval(k, range.clone());
                if query.separate_range(&range) {
                    return;
                }
                if query.contain_range(&range) {
                    self.lazy[k] += range.width() as i64 * x;
                    self.eval(k, range.clone());
                } else {
                    self.addrec(
                        query.clone(),
                        x,
                        2 * k + 1,
                        range.start..(range.start + range.end) / 2,
                    );
                    self.addrec(
                        query.clone(),
                        x,
                        2 * k + 2,
                        (range.start + range.end) / 2..range.end,
                    );
                    self.node[k] = self.node[2 * k + 1] + self.node[2 * k + 2];
                }
            }
            pub fn sum<T>(&mut self, query: T) -> i64
            where
                T: RangeBounds<i32>,
            {
                let n = self.n;
                self.sumrec(query.to_range(0, n), 0, 0..n)
            }
            fn sumrec(&mut self, query: Range<i32>, k: i32, range: Range<i32>) -> i64 {
                if query.separate_range(&range) {
                    return 0;
                }
                self.eval(k, range.clone());
                if query.contain_range(&range) {
                    return self.node[k];
                }
                let vl = self.sumrec(
                    query.clone(),
                    2 * k + 1,
                    range.start..(range.start + range.end) / 2,
                );
                let vr = self.sumrec(
                    query.clone(),
                    2 * k + 2,
                    (range.start + range.end) / 2..range.end,
                );
                vl + vr
            }
        }
        pub struct SegRangeUpdate<'a> {
            node: List<i64>,
            lazy: List<i64>,
            has_lazy: List<bool>,
            op: Box<dyn Fn(i64, i64) -> i64 + 'a>,
            zero: i64,
            n: i32,
        }
        impl<'a> SegRangeUpdate<'a> {
            pub fn new<B>(v: List<i64>, zero: i64, op: B) -> SegRangeUpdate<'a>
            where
                B: Fn(i64, i64) -> i64 + 'a,
            {
                let size = v.ilen();
                let mut n = 1i32;
                while n < size {
                    n *= 2
                }
                let mut node = List::init(zero, 2 * n - 1);
                let lazy = List::init(0, 2 * n - 1);
                let has_lazy = List::init(false, 2 * n - 1);
                for i in 0..size {
                    node[i + n - 1] = v[i]
                }
                for i in (0..n - 1).rev() {
                    node[i] = op(node[i * 2 + 1], node[i * 2 + 2])
                }
                SegRangeUpdate {
                    node,
                    lazy,
                    has_lazy,
                    op: Box::new(op),
                    zero,
                    n,
                }
            }
            fn eval(&mut self, k: i32, range: Range<i32>) {
                if self.has_lazy[k] {
                    self.node[k] = self.lazy[k];
                    if range.width() > 1 {
                        self.lazy[2 * k + 1] = self.lazy[k];
                        self.lazy[2 * k + 2] = self.lazy[k];
                        self.has_lazy[2 * k + 1] = true;
                        self.has_lazy[2 * k + 2] = true;
                    }
                    self.has_lazy[k] = false;
                }
            }
            pub fn set<T>(&mut self, query: T, x: i64)
            where
                T: RangeBounds<i32>,
            {
                let n = self.n;
                self.setrec(query.to_range(0, n), x, 0, 0..n)
            }
            fn setrec(&mut self, query: Range<i32>, x: i64, k: i32, range: Range<i32>) {
                self.eval(k, range.clone());
                if query.separate_range(&range) {
                    return;
                }
                if query.contain_range(&range) {
                    self.lazy[k] = x;
                    self.has_lazy[k] = true;
                    self.eval(k, range.clone());
                } else {
                    self.setrec(
                        query.clone(),
                        x,
                        2 * k + 1,
                        range.start..(range.start + range.end) / 2,
                    );
                    self.setrec(
                        query.clone(),
                        x,
                        2 * k + 2,
                        (range.start + range.end) / 2..range.end,
                    );
                    self.node[k] = (self.op)(self.node[2 * k + 1], self.node[2 * k + 2]);
                }
            }
            pub fn get<T>(&mut self, query: T) -> i64
            where
                T: RangeBounds<i32>,
            {
                let n = self.n;
                self.getrec(query.to_range(0, n), 0, 0..n)
            }
            fn getrec(&mut self, query: Range<i32>, k: i32, range: Range<i32>) -> i64 {
                if query.separate_range(&range) {
                    return self.zero;
                }
                self.eval(k, range.clone());
                if query.contain_range(&range) {
                    return self.node[k];
                }
                let vl = self.getrec(
                    query.clone(),
                    2 * k + 1,
                    range.start..(range.start + range.end) / 2,
                );
                let vr = self.getrec(
                    query.clone(),
                    2 * k + 2,
                    (range.start + range.end) / 2..range.end,
                );
                (self.op)(vl, vr)
            }
        }
        pub struct SegIndexTree<'a> {
            node: List<(i64, i32)>,
            zero: i64,
            op: Box<dyn Fn((i64, i32), (i64, i32)) -> (i64, i32) + 'a>,
            n: i32,
        }
        impl<'a> SegIndexTree<'a> {
            pub fn new<B>(v: List<i64>, zero: i64, op: B) -> SegIndexTree<'a>
            where
                B: Fn((i64, i32), (i64, i32)) -> (i64, i32) + 'a,
            {
                let size = v.ilen();
                let mut n = 1i32;
                while n < size {
                    n *= 2
                }
                let mut node = List::init((zero, 0), 2 * n - 1);
                for i in 0..size {
                    node[i + n - 1] = (v[i], i)
                }
                for i in (0..n - 1).rev() {
                    node[i] = op(node[2 * i + 1], node[2 * i + 2])
                }
                SegIndexTree {
                    node: node,
                    zero: zero,
                    op: Box::new(op),
                    n: n,
                }
            }
            pub fn set(&mut self, mut x: i32, value: i64) {
                let y = x;
                x += self.n - 1;
                self.node[x] = (value, y);
                while x > 0 {
                    x = (x - 1) / 2;
                    self.node[x] = (self.op)(self.node[2 * x + 1], self.node[2 * x + 2]);
                }
            }
            pub fn get1(&self, i: i32) -> (i64, i32) {
                self.getrec(i..i + 1, 0, 0..self.n)
            }
            pub fn get<T>(&self, query: T) -> (i64, i32)
            where
                T: RangeBounds<i32>,
            {
                self.getrec(query.to_range(0, self.n), 0, 0..self.n)
            }
            fn getrec(&self, query: Range<i32>, k: i32, range: Range<i32>) -> (i64, i32) {
                if query.separate_range(&range) {
                    return (self.zero, 0);
                }
                if query.contain_range(&range) {
                    return self.node[k];
                }
                let vl = self.getrec(
                    query.clone(),
                    2 * k + 1,
                    range.start..(range.start + range.end) / 2,
                );
                let vr = self.getrec(
                    query.clone(),
                    2 * k + 2,
                    (range.start + range.end) / 2..range.end,
                );
                (self.op)(vl, vr)
            }
        }
    }
}