Trait proc_bitfield::Bits

pub trait Bits<T> {
    // Required method
    fn bits<const START: usize, const END: usize>(&self) -> T;
}

Read a range of bits inside a value.

Required Methods

fn bits<const START: usize, const END: usize>(&self) -> T

Read self’s START..END bit range (with END excluded) as a value of type T.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl Bits<i8> for i8

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for i16

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for i32

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for i64

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for i128

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for isize

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for u8

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for u16

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for u32

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for u64

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for u128

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for usize

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i16> for i8

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for i16

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for i32

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for i64

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for i128

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for isize

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for u8

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for u16

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for u32

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for u64

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for u128

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for usize

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i32> for i8

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for i16

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for i32

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for i64

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for i128

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for isize

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for u8

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for u16

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for u32

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for u64

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for u128

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for usize

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i64> for i8

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for i16

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for i32

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for i64

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for i128

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for isize

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for u8

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for u16

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for u32

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for u64

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for u128

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for usize

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i128> for i8

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for i16

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for i32

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for i64

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for i128

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for isize

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for u8

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for u16

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for u32

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for u64

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for u128

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for usize

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<isize> for i8

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for i16

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for i32

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for i64

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for i128

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for isize

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for u8

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for u16

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for u32

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for u64

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for u128

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for usize

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<u8> for i8

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for i16

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for i32

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for i64

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for i128

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for isize

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for u8

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for u16

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for u32

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for u64

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for u128

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for usize

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u16> for i8

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for i16

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for i32

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for i64

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for i128

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for isize

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for u8

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for u16

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for u32

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for u64

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for u128

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for usize

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u32> for i8

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for i16

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for i32

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for i64

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for i128

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for isize

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for u8

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for u16

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for u32

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for u64

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for u128

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for usize

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u64> for i8

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for i16

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for i32

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for i64

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for i128

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for isize

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for u8

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for u16

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for u32

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for u64

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for u128

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for usize

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u128> for i8

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for i16

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for i32

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for i64

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for i128

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for isize

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for u8

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for u16

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for u32

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for u64

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for u128

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for usize

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<usize> for i8

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for i16

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for i32

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for i64

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for i128

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for isize

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for u8

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for u16

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for u32

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for u64

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for u128

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for usize

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> usize

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for usize

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

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

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const N: usize> Bits<i8> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i16> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i32> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i64> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i128> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<isize> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<u8> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u16> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u32> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u64> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u128> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<usize> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

Implementors