use std::ops::{AddAssign, SubAssign};

struct XorVal {
    data: Vec<i32>,
    count: usize,
}
impl XorVal {
    pub fn new() -> Self {
        XorVal { data: vec!(0; 32), count: 0 }
    }
    pub fn get_val(&self) -> i32 {
        if self.count == 0 {
            return -1;
        }
        let mut ans = 0;
        for i in 0..32 {
            if self.data[i] > 0 {
                ans |= 1 << i;
            }
        }
        ans
    }
}
impl AddAssign<i32> for XorVal {
    fn add_assign(&mut self, mut x: i32) {
        self.count += 1;
        let mut i = 0;
        while x > 0 {
            if x & 1 == 1 {
                self.data[i] += 1;
            }
            x >>= 1;
            i += 1;
        }
    }
}
impl SubAssign<i32> for XorVal {
    fn sub_assign(&mut self, mut x: i32) {
        self.count -= 1;
        let mut i = 0;
        while x > 0 {
            if x & 1 == 1 {
                self.data[i] -= 1;
            }
            x >>= 1;
            i += 1;
        }
    }
}
struct Solution;
impl Solution {
    pub fn smallest_subarrays(nums: Vec<i32>) -> Vec<i32> {
        let mut ans = vec![0; nums.len()];
        let mut xor = vec![0; nums.len()];
        xor[nums.len() - 1] = nums[nums.len() - 1];
        for i in (0..nums.len() - 1).rev() {
            xor[i] = xor[i + 1] | nums[i];
        }
        let mut xor_val = XorVal::new();
        let (mut l, mut r) = (0, 0);
        for i in 0..nums.len() {
            while l < i && l <= r {
                xor_val -= nums[l];
                l += 1;
            }
            while xor_val.get_val() < xor[i] {
                xor_val += nums[r];
                r += 1;
            }
            ans[i] = (r - l) as i32;
        }
        ans
    }
}

fn main() {
    let sl = Solution::smallest_subarrays(vec![0]);
    println!("{:?}", sl);
}