Trait proc_bitfield::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.

Object Safety

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<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