Trait SetBits

pub trait SetBits<T> {
    // Required method
    fn set_bits<const START: usize, const END: usize>(&mut self, value: T);
}

Modify a range of bits inside a value in place.

Required Methods

fn set_bits<const START: usize, const END: usize>(&mut self, value: T)

Sets self’s START..END bit range (with END excluded) to the given value of type T in place.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl SetBits<i8> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i8> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl SetBits<i16> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i16> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl SetBits<i32> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i32> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl SetBits<i64> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i64> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl SetBits<i128> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<i128> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl SetBits<isize> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<isize> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl SetBits<u8> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u8> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl SetBits<u16> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u16> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl SetBits<u32> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u32> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl SetBits<u64> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u64> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl SetBits<u128> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<u128> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl SetBits<usize> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<usize> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl SetBits<UnwrapBitsExample> for i8

where UnwrapBitsExample: TryFrom<i8> + Into<i8>, <UnwrapBitsExample as TryFrom<i8>>::Error: Debug,

fn set_bits<const START: usize, const END: usize>( &mut self, value: UnwrapBitsExample, )

impl SetBits<UnwrapBitsExample> for i16

where UnwrapBitsExample: TryFrom<i16> + Into<i16>, <UnwrapBitsExample as TryFrom<i16>>::Error: Debug,

fn set_bits<const START: usize, const END: usize>( &mut self, value: UnwrapBitsExample, )

impl SetBits<UnwrapBitsExample> for i32

where UnwrapBitsExample: TryFrom<i32> + Into<i32>, <UnwrapBitsExample as TryFrom<i32>>::Error: Debug,

fn set_bits<const START: usize, const END: usize>( &mut self, value: UnwrapBitsExample, )

impl SetBits<UnwrapBitsExample> for i64

where UnwrapBitsExample: TryFrom<i64> + Into<i64>, <UnwrapBitsExample as TryFrom<i64>>::Error: Debug,

fn set_bits<const START: usize, const END: usize>( &mut self, value: UnwrapBitsExample, )

impl SetBits<UnwrapBitsExample> for i128

where UnwrapBitsExample: TryFrom<i128> + Into<i128>, <UnwrapBitsExample as TryFrom<i128>>::Error: Debug,

fn set_bits<const START: usize, const END: usize>( &mut self, value: UnwrapBitsExample, )

impl SetBits<UnwrapBitsExample> for u8

where UnwrapBitsExample: TryFrom<u8> + Into<u8>, <UnwrapBitsExample as TryFrom<u8>>::Error: Debug,

fn set_bits<const START: usize, const END: usize>( &mut self, value: UnwrapBitsExample, )

impl SetBits<UnwrapBitsExample> for u16

where UnwrapBitsExample: TryFrom<u16> + Into<u16>, <UnwrapBitsExample as TryFrom<u16>>::Error: Debug,

fn set_bits<const START: usize, const END: usize>( &mut self, value: UnwrapBitsExample, )

impl SetBits<UnwrapBitsExample> for u32

where UnwrapBitsExample: TryFrom<u32> + Into<u32>, <UnwrapBitsExample as TryFrom<u32>>::Error: Debug,

fn set_bits<const START: usize, const END: usize>( &mut self, value: UnwrapBitsExample, )

impl SetBits<UnwrapBitsExample> for u64

where UnwrapBitsExample: TryFrom<u64> + Into<u64>, <UnwrapBitsExample as TryFrom<u64>>::Error: Debug,

fn set_bits<const START: usize, const END: usize>( &mut self, value: UnwrapBitsExample, )

impl SetBits<UnwrapBitsExample> for u128

where UnwrapBitsExample: TryFrom<u128> + Into<u128>, <UnwrapBitsExample as TryFrom<u128>>::Error: Debug,

fn set_bits<const START: usize, const END: usize>( &mut self, value: UnwrapBitsExample, )

impl<const M: usize> SetBits<[i8; M]> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i8; M]> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize> SetBits<[i16; M]> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i16; M]> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize> SetBits<[i32; M]> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i32; M]> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize> SetBits<[i64; M]> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i64; M]> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize> SetBits<[i128; M]> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[i128; M]> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize> SetBits<[isize; M]> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[isize; M]> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize> SetBits<[u8; M]> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u8; M]> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize> SetBits<[u16; M]> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u16; M]> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize> SetBits<[u32; M]> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u32; M]> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize> SetBits<[u64; M]> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u64; M]> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize> SetBits<[u128; M]> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[u128; M]> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize> SetBits<[usize; M]> for i8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for i16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for i32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for i64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for i128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for isize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for u8

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for u16

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for u32

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for u64

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for u128

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for usize

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for [i8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for [i16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for [i32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for [i64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for [i128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for [isize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for [u8]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for [u16]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for [u32]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for [u64]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for [u128]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize> SetBits<[usize; M]> for [usize]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize, const N: usize> SetBits<[i8; M]> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize, const N: usize> SetBits<[i8; M]> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize, const N: usize> SetBits<[i8; M]> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize, const N: usize> SetBits<[i8; M]> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize, const N: usize> SetBits<[i8; M]> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize, const N: usize> SetBits<[i8; M]> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize, const N: usize> SetBits<[i8; M]> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize, const N: usize> SetBits<[i8; M]> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize, const N: usize> SetBits<[i8; M]> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize, const N: usize> SetBits<[i8; M]> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize, const N: usize> SetBits<[i8; M]> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize, const N: usize> SetBits<[i8; M]> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i8; M])

impl<const M: usize, const N: usize> SetBits<[i16; M]> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize, const N: usize> SetBits<[i16; M]> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize, const N: usize> SetBits<[i16; M]> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize, const N: usize> SetBits<[i16; M]> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize, const N: usize> SetBits<[i16; M]> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize, const N: usize> SetBits<[i16; M]> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize, const N: usize> SetBits<[i16; M]> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize, const N: usize> SetBits<[i16; M]> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize, const N: usize> SetBits<[i16; M]> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize, const N: usize> SetBits<[i16; M]> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize, const N: usize> SetBits<[i16; M]> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize, const N: usize> SetBits<[i16; M]> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i16; M])

impl<const M: usize, const N: usize> SetBits<[i32; M]> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize, const N: usize> SetBits<[i32; M]> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize, const N: usize> SetBits<[i32; M]> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize, const N: usize> SetBits<[i32; M]> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize, const N: usize> SetBits<[i32; M]> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize, const N: usize> SetBits<[i32; M]> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize, const N: usize> SetBits<[i32; M]> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize, const N: usize> SetBits<[i32; M]> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize, const N: usize> SetBits<[i32; M]> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize, const N: usize> SetBits<[i32; M]> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize, const N: usize> SetBits<[i32; M]> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize, const N: usize> SetBits<[i32; M]> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i32; M])

impl<const M: usize, const N: usize> SetBits<[i64; M]> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize, const N: usize> SetBits<[i64; M]> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize, const N: usize> SetBits<[i64; M]> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize, const N: usize> SetBits<[i64; M]> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize, const N: usize> SetBits<[i64; M]> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize, const N: usize> SetBits<[i64; M]> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize, const N: usize> SetBits<[i64; M]> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize, const N: usize> SetBits<[i64; M]> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize, const N: usize> SetBits<[i64; M]> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize, const N: usize> SetBits<[i64; M]> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize, const N: usize> SetBits<[i64; M]> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize, const N: usize> SetBits<[i64; M]> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i64; M])

impl<const M: usize, const N: usize> SetBits<[i128; M]> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize, const N: usize> SetBits<[i128; M]> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize, const N: usize> SetBits<[i128; M]> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize, const N: usize> SetBits<[i128; M]> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize, const N: usize> SetBits<[i128; M]> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize, const N: usize> SetBits<[i128; M]> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize, const N: usize> SetBits<[i128; M]> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize, const N: usize> SetBits<[i128; M]> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize, const N: usize> SetBits<[i128; M]> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize, const N: usize> SetBits<[i128; M]> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize, const N: usize> SetBits<[i128; M]> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize, const N: usize> SetBits<[i128; M]> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [i128; M])

impl<const M: usize, const N: usize> SetBits<[isize; M]> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize, const N: usize> SetBits<[isize; M]> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize, const N: usize> SetBits<[isize; M]> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize, const N: usize> SetBits<[isize; M]> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize, const N: usize> SetBits<[isize; M]> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize, const N: usize> SetBits<[isize; M]> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize, const N: usize> SetBits<[isize; M]> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize, const N: usize> SetBits<[isize; M]> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize, const N: usize> SetBits<[isize; M]> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize, const N: usize> SetBits<[isize; M]> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize, const N: usize> SetBits<[isize; M]> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize, const N: usize> SetBits<[isize; M]> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [isize; M])

impl<const M: usize, const N: usize> SetBits<[u8; M]> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize, const N: usize> SetBits<[u8; M]> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize, const N: usize> SetBits<[u8; M]> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize, const N: usize> SetBits<[u8; M]> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize, const N: usize> SetBits<[u8; M]> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize, const N: usize> SetBits<[u8; M]> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize, const N: usize> SetBits<[u8; M]> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize, const N: usize> SetBits<[u8; M]> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize, const N: usize> SetBits<[u8; M]> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize, const N: usize> SetBits<[u8; M]> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize, const N: usize> SetBits<[u8; M]> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize, const N: usize> SetBits<[u8; M]> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u8; M])

impl<const M: usize, const N: usize> SetBits<[u16; M]> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize, const N: usize> SetBits<[u16; M]> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize, const N: usize> SetBits<[u16; M]> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize, const N: usize> SetBits<[u16; M]> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize, const N: usize> SetBits<[u16; M]> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize, const N: usize> SetBits<[u16; M]> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize, const N: usize> SetBits<[u16; M]> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize, const N: usize> SetBits<[u16; M]> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize, const N: usize> SetBits<[u16; M]> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize, const N: usize> SetBits<[u16; M]> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize, const N: usize> SetBits<[u16; M]> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize, const N: usize> SetBits<[u16; M]> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u16; M])

impl<const M: usize, const N: usize> SetBits<[u32; M]> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize, const N: usize> SetBits<[u32; M]> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize, const N: usize> SetBits<[u32; M]> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize, const N: usize> SetBits<[u32; M]> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize, const N: usize> SetBits<[u32; M]> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize, const N: usize> SetBits<[u32; M]> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize, const N: usize> SetBits<[u32; M]> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize, const N: usize> SetBits<[u32; M]> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize, const N: usize> SetBits<[u32; M]> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize, const N: usize> SetBits<[u32; M]> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize, const N: usize> SetBits<[u32; M]> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize, const N: usize> SetBits<[u32; M]> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u32; M])

impl<const M: usize, const N: usize> SetBits<[u64; M]> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize, const N: usize> SetBits<[u64; M]> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize, const N: usize> SetBits<[u64; M]> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize, const N: usize> SetBits<[u64; M]> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize, const N: usize> SetBits<[u64; M]> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize, const N: usize> SetBits<[u64; M]> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize, const N: usize> SetBits<[u64; M]> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize, const N: usize> SetBits<[u64; M]> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize, const N: usize> SetBits<[u64; M]> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize, const N: usize> SetBits<[u64; M]> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize, const N: usize> SetBits<[u64; M]> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize, const N: usize> SetBits<[u64; M]> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u64; M])

impl<const M: usize, const N: usize> SetBits<[u128; M]> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize, const N: usize> SetBits<[u128; M]> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize, const N: usize> SetBits<[u128; M]> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize, const N: usize> SetBits<[u128; M]> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize, const N: usize> SetBits<[u128; M]> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize, const N: usize> SetBits<[u128; M]> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize, const N: usize> SetBits<[u128; M]> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize, const N: usize> SetBits<[u128; M]> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize, const N: usize> SetBits<[u128; M]> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize, const N: usize> SetBits<[u128; M]> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize, const N: usize> SetBits<[u128; M]> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize, const N: usize> SetBits<[u128; M]> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [u128; M])

impl<const M: usize, const N: usize> SetBits<[usize; M]> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize, const N: usize> SetBits<[usize; M]> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize, const N: usize> SetBits<[usize; M]> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize, const N: usize> SetBits<[usize; M]> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize, const N: usize> SetBits<[usize; M]> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize, const N: usize> SetBits<[usize; M]> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize, const N: usize> SetBits<[usize; M]> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize, const N: usize> SetBits<[usize; M]> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize, const N: usize> SetBits<[usize; M]> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize, const N: usize> SetBits<[usize; M]> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize, const N: usize> SetBits<[usize; M]> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const M: usize, const N: usize> SetBits<[usize; M]> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: [usize; M])

impl<const N: usize> SetBits<i8> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl<const N: usize> SetBits<i8> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl<const N: usize> SetBits<i8> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl<const N: usize> SetBits<i8> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl<const N: usize> SetBits<i8> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl<const N: usize> SetBits<i8> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl<const N: usize> SetBits<i8> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl<const N: usize> SetBits<i8> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl<const N: usize> SetBits<i8> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl<const N: usize> SetBits<i8> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl<const N: usize> SetBits<i8> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl<const N: usize> SetBits<i8> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i8)

impl<const N: usize> SetBits<i16> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl<const N: usize> SetBits<i16> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl<const N: usize> SetBits<i16> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl<const N: usize> SetBits<i16> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl<const N: usize> SetBits<i16> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl<const N: usize> SetBits<i16> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl<const N: usize> SetBits<i16> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl<const N: usize> SetBits<i16> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl<const N: usize> SetBits<i16> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl<const N: usize> SetBits<i16> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl<const N: usize> SetBits<i16> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl<const N: usize> SetBits<i16> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i16)

impl<const N: usize> SetBits<i32> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl<const N: usize> SetBits<i32> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl<const N: usize> SetBits<i32> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl<const N: usize> SetBits<i32> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl<const N: usize> SetBits<i32> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl<const N: usize> SetBits<i32> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl<const N: usize> SetBits<i32> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl<const N: usize> SetBits<i32> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl<const N: usize> SetBits<i32> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl<const N: usize> SetBits<i32> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl<const N: usize> SetBits<i32> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl<const N: usize> SetBits<i32> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i32)

impl<const N: usize> SetBits<i64> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl<const N: usize> SetBits<i64> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl<const N: usize> SetBits<i64> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl<const N: usize> SetBits<i64> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl<const N: usize> SetBits<i64> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl<const N: usize> SetBits<i64> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl<const N: usize> SetBits<i64> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl<const N: usize> SetBits<i64> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl<const N: usize> SetBits<i64> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl<const N: usize> SetBits<i64> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl<const N: usize> SetBits<i64> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl<const N: usize> SetBits<i64> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i64)

impl<const N: usize> SetBits<i128> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl<const N: usize> SetBits<i128> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl<const N: usize> SetBits<i128> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl<const N: usize> SetBits<i128> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl<const N: usize> SetBits<i128> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl<const N: usize> SetBits<i128> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl<const N: usize> SetBits<i128> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl<const N: usize> SetBits<i128> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl<const N: usize> SetBits<i128> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl<const N: usize> SetBits<i128> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl<const N: usize> SetBits<i128> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl<const N: usize> SetBits<i128> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: i128)

impl<const N: usize> SetBits<isize> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl<const N: usize> SetBits<isize> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl<const N: usize> SetBits<isize> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl<const N: usize> SetBits<isize> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl<const N: usize> SetBits<isize> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl<const N: usize> SetBits<isize> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl<const N: usize> SetBits<isize> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl<const N: usize> SetBits<isize> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl<const N: usize> SetBits<isize> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl<const N: usize> SetBits<isize> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl<const N: usize> SetBits<isize> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl<const N: usize> SetBits<isize> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: isize)

impl<const N: usize> SetBits<u8> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl<const N: usize> SetBits<u8> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl<const N: usize> SetBits<u8> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl<const N: usize> SetBits<u8> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl<const N: usize> SetBits<u8> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl<const N: usize> SetBits<u8> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl<const N: usize> SetBits<u8> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl<const N: usize> SetBits<u8> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl<const N: usize> SetBits<u8> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl<const N: usize> SetBits<u8> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl<const N: usize> SetBits<u8> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl<const N: usize> SetBits<u8> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u8)

impl<const N: usize> SetBits<u16> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl<const N: usize> SetBits<u16> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl<const N: usize> SetBits<u16> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl<const N: usize> SetBits<u16> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl<const N: usize> SetBits<u16> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl<const N: usize> SetBits<u16> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl<const N: usize> SetBits<u16> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl<const N: usize> SetBits<u16> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl<const N: usize> SetBits<u16> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl<const N: usize> SetBits<u16> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl<const N: usize> SetBits<u16> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl<const N: usize> SetBits<u16> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u16)

impl<const N: usize> SetBits<u32> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl<const N: usize> SetBits<u32> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl<const N: usize> SetBits<u32> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl<const N: usize> SetBits<u32> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl<const N: usize> SetBits<u32> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl<const N: usize> SetBits<u32> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl<const N: usize> SetBits<u32> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl<const N: usize> SetBits<u32> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl<const N: usize> SetBits<u32> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl<const N: usize> SetBits<u32> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl<const N: usize> SetBits<u32> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl<const N: usize> SetBits<u32> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u32)

impl<const N: usize> SetBits<u64> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl<const N: usize> SetBits<u64> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl<const N: usize> SetBits<u64> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl<const N: usize> SetBits<u64> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl<const N: usize> SetBits<u64> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl<const N: usize> SetBits<u64> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl<const N: usize> SetBits<u64> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl<const N: usize> SetBits<u64> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl<const N: usize> SetBits<u64> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl<const N: usize> SetBits<u64> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl<const N: usize> SetBits<u64> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl<const N: usize> SetBits<u64> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u64)

impl<const N: usize> SetBits<u128> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl<const N: usize> SetBits<u128> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl<const N: usize> SetBits<u128> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl<const N: usize> SetBits<u128> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl<const N: usize> SetBits<u128> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl<const N: usize> SetBits<u128> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl<const N: usize> SetBits<u128> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl<const N: usize> SetBits<u128> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl<const N: usize> SetBits<u128> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl<const N: usize> SetBits<u128> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl<const N: usize> SetBits<u128> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl<const N: usize> SetBits<u128> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: u128)

impl<const N: usize> SetBits<usize> for [i8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl<const N: usize> SetBits<usize> for [i16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl<const N: usize> SetBits<usize> for [i32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl<const N: usize> SetBits<usize> for [i64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl<const N: usize> SetBits<usize> for [i128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl<const N: usize> SetBits<usize> for [isize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl<const N: usize> SetBits<usize> for [u8; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl<const N: usize> SetBits<usize> for [u16; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl<const N: usize> SetBits<usize> for [u32; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl<const N: usize> SetBits<usize> for [u64; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl<const N: usize> SetBits<usize> for [u128; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

impl<const N: usize> SetBits<usize> for [usize; N]

fn set_bits<const START: usize, const END: usize>(&mut self, value: usize)

Implementors