android/vendor/bitvec-1.0.1/src/macros/internal.rs - toolchain/cargo-deny - Git at Google

 #![doc(hidden)]
 #![doc = include_str!("../../doc/macros/internal.md")]

 //  Provide known mount-points of dependency crates.

 #[doc(hidden)]
 pub use core;

 #[doc(hidden)]
 pub use funty;

 #[doc(hidden)]
 #[macro_export]
 #[doc = include_str!("../../doc/macros/encode_bits.md")]
 macro_rules! __encode_bits {
 	/* ENTRY POINTS
 	 *
 	 * These arms match the syntax provided by the public macros, and dispatch
 	 * by storage type width.
 	 */

 	(u8, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(u8 as u8, $ord; $($val),*)
 	};
 	(Cell<u8>, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(Cell<u8> as u8, $ord; $($val),*)
 	};
 	(AtomicU8, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(AtomicU8 as u8, $ord; $($val),*)
 	};
 	(RadiumU8, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(RadiumU8 as u8, $ord; $($val),*)
 	};

 	(u16, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(u16 as u16, $ord; $($val),*)
 	};
 	(Cell<u16>, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(Cell<u16> as u16, $ord; $($val),*)
 	};
 	(AtomicU16, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(AtomicU16 as u16, $ord; $($val),*)
 	};
 	(RadiumU16, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(RadiumU16 as u16, $ord; $($val),*)
 	};

 	(u32, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(u32 as u32, $ord; $($val),*)
 	};
 	(Cell<u32>, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(Cell<u32> as u32, $ord; $($val),*)
 	};
 	(AtomicU32, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(AtomicU32 as u32, $ord; $($val),*)
 	};
 	(RadiumU32, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(RadiumU32 as u32, $ord; $($val),*)
 	};

 	(u64, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(u64 as u64, $ord; $($val),*)
 	};
 	(Cell<u64>, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(Cell<u64> as u64, $ord; $($val),*)
 	};
 	(AtomicU64, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(AtomicU64 as u64, $ord; $($val),*)
 	};
 	(RadiumU64, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(RadiumU64 as u64, $ord; $($val),*)
 	};

 	(usize, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(usize as usize, $ord; $($val),*)
 	};
 	(Cell<usize>, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(Cell<usize> as usize, $ord; $($val),*)
 	};
 	(AtomicUsize, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(AtomicUsize as usize, $ord; $($val),*)
 	};
 	(RadiumUsize, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(RadiumUsize as usize, $ord; $($val),*)
 	};

 	//  This arm routes `usize` into `u32` or `u64`, depending on target, and
 	//  marks them to return to `usize` after chunking.
 	($typ:ty as usize, $ord:tt; $($val:expr),*) => {{
 		const LEN: usize = $crate::__count_elts!(usize; $($val),*);

 		let out: [$typ; LEN];

 		#[cfg(target_pointer_width = "32")]
 		{
 			out = $crate::__encode_bits!($typ as u32 as usize, $ord; $($val),*);
 		}

 		#[cfg(target_pointer_width = "64")]
 		{
 			out = $crate::__encode_bits!($typ as u64 as usize, $ord; $($val),*);
 		}

 		out
 	}};

 	//  ZERO EXTENSION: Supply literal `0, ` tokens to ensure that elements can
 	//  be completely filled with bits.
 	($typ:ty as $uint:ident $(as $usz:ident)?, $ord:tt; $($val:expr),*) => {
 		$crate::__encode_bits!(
 			$typ as $uint $(as $usz)?, $ord; []; $($val,)*
 			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16
 			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 32
 			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 48
 			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 64
 		)
 	};

 	/* EXIT POINT.
 	 *
 	 * This arm enters once the only remaining bit-expression tokens are the
 	 * literal `0, `s provided above. It does not enter while any opaque
 	 * user-provided bit expressions remain, and matching falls through to the
 	 * chunkers, below.
 	 *
 	 * Once entered, this converts each chunk of bit expressions into the
 	 * requested storage element, then emits an array of the encoded elements.
 	 * This array is the final value of the originally-invoked macro. The
 	 * invoker is responsible for turning the array into a `bitvec` type.
 	 */
 	(
 		$typ:ty as $uint:ident as usize, $ord:tt;
 		[$([$($bit:tt,)+],)*]; $(0,)*
 	) => {
 		[$($crate::__make_elem!($typ as $uint as usize, $ord; $($bit,)+),)*]
 	};
 	(
 		$typ:ty as $uint:ident, $ord:tt;
 		[$([$($bit:tt,)+],)*]; $(0,)*
 	) => {
 		[$($crate::__make_elem!($typ as $uint, $ord; $($bit,)+),)*]
 	};

 	/* CHUNKERS
 	 *
 	 * These arms munch through the token stream, creating a sequence of chunks
 	 * of bits. Each chunk contains bits to exactly fill one element, and gets
 	 * passed into `__make_elem!` for final encoding.
 	 */

 	(
 		$typ:ty as u8, $ord:tt; [$($elem:tt)*];
 		$a0:tt, $b0:tt, $c0:tt, $d0:tt, $e0:tt, $f0:tt, $g0:tt, $h0:tt,
 		$($t:tt)*
 	) => {
 		$crate::__encode_bits!(
 			$typ as u8, $ord; [$($elem)* [
 				$a0, $b0, $c0, $d0, $e0, $f0, $g0, $h0,
 			],]; $($t)*
 		)
 	};

 	(
 		$typ:ty as u16, $ord:tt; [$($elem:tt)*];
 		$a0:tt, $b0:tt, $c0:tt, $d0:tt, $e0:tt, $f0:tt, $g0:tt, $h0:tt,
 		$a1:tt, $b1:tt, $c1:tt, $d1:tt, $e1:tt, $f1:tt, $g1:tt, $h1:tt,
 		$($t:tt)*
 	) => {
 		$crate::__encode_bits!(
 			$typ as u16, $ord; [$($elem)* [
 				$a0, $b0, $c0, $d0, $e0, $f0, $g0, $h0,
 				$a1, $b1, $c1, $d1, $e1, $f1, $g1, $h1,
 			],]; $($t)*
 		)
 	};

 	(
 		$typ:ty as u32 $(as $usz:ident)?, $ord:tt; [$($elem:tt)*];
 		$a0:tt, $b0:tt, $c0:tt, $d0:tt, $e0:tt, $f0:tt, $g0:tt, $h0:tt,
 		$a1:tt, $b1:tt, $c1:tt, $d1:tt, $e1:tt, $f1:tt, $g1:tt, $h1:tt,
 		$a2:tt, $b2:tt, $c2:tt, $d2:tt, $e2:tt, $f2:tt, $g2:tt, $h2:tt,
 		$a3:tt, $b3:tt, $c3:tt, $d3:tt, $e3:tt, $f3:tt, $g3:tt, $h3:tt,
 		$($t:tt)*
 	) => {
 		$crate::__encode_bits!(
 			$typ as u32 $(as $usz)?, $ord; [$($elem)* [
 				$a0, $b0, $c0, $d0, $e0, $f0, $g0, $h0,
 				$a1, $b1, $c1, $d1, $e1, $f1, $g1, $h1,
 				$a2, $b2, $c2, $d2, $e2, $f2, $g2, $h2,
 				$a3, $b3, $c3, $d3, $e3, $f3, $g3, $h3,
 			],]; $($t)*
 		)
 	};

 	(
 		$typ:ty as u64 $(as $usz:ident)?, $ord:tt; [$($elem:tt)*];
 		$a0:tt, $b0:tt, $c0:tt, $d0:tt, $e0:tt, $f0:tt, $g0:tt, $h0:tt,
 		$a1:tt, $b1:tt, $c1:tt, $d1:tt, $e1:tt, $f1:tt, $g1:tt, $h1:tt,
 		$a2:tt, $b2:tt, $c2:tt, $d2:tt, $e2:tt, $f2:tt, $g2:tt, $h2:tt,
 		$a3:tt, $b3:tt, $c3:tt, $d3:tt, $e3:tt, $f3:tt, $g3:tt, $h3:tt,
 		$a4:tt, $b4:tt, $c4:tt, $d4:tt, $e4:tt, $f4:tt, $g4:tt, $h4:tt,
 		$a5:tt, $b5:tt, $c5:tt, $d5:tt, $e5:tt, $f5:tt, $g5:tt, $h5:tt,
 		$a6:tt, $b6:tt, $c6:tt, $d6:tt, $e6:tt, $f6:tt, $g6:tt, $h6:tt,
 		$a7:tt, $b7:tt, $c7:tt, $d7:tt, $e7:tt, $f7:tt, $g7:tt, $h7:tt,
 		$($t:tt)*
 	) => {
 		$crate::__encode_bits!(
 			$typ as u64 $(as $usz)?, $ord; [$($elem)* [
 				$a0, $b0, $c0, $d0, $e0, $f0, $g0, $h0,
 				$a1, $b1, $c1, $d1, $e1, $f1, $g1, $h1,
 				$a2, $b2, $c2, $d2, $e2, $f2, $g2, $h2,
 				$a3, $b3, $c3, $d3, $e3, $f3, $g3, $h3,
 				$a4, $b4, $c4, $d4, $e4, $f4, $g4, $h4,
 				$a5, $b5, $c5, $d5, $e5, $f5, $g5, $h5,
 				$a6, $b6, $c6, $d6, $e6, $f6, $g6, $h6,
 				$a7, $b7, $c7, $d7, $e7, $f7, $g7, $h7,
 			],]; $($t)*
 		)
 	};
 }

 /// Counts the number of expression tokens in a repetition sequence.
 #[doc(hidden)]
 #[macro_export]
 macro_rules! __count {
 	(@ $val:expr) => { 1 };
 	($($val:expr),* $(,)?) => {{
 		const LEN: usize = 0 $(+ $crate::__count!(@ $val))*;
 		LEN
 	}};
 }

 /// Counts the number of storage elements needed to store a bit sequence.
 #[doc(hidden)]
 #[macro_export]
 macro_rules! __count_elts {
 	($t:ty; $($val:expr),*) => {
 		$crate::mem::elts::<$t>($crate::__count!($($val),*))
 	};
 }

 #[doc(hidden)]
 #[macro_export]
 #[doc = include_str!("../../doc/macros/make_elem.md")]
 macro_rules! __make_elem {
 	//  Token-matching ordering names can use specialized work.
 	($typ:ty as $uint:ident $(as $usz:ident)?, Lsb0; $(
 		$a:expr, $b:expr, $c:expr, $d:expr,
 		$e:expr, $f:expr, $g:expr, $h:expr,
 	)*) => {{
 		const ELEM: $uint = $crate::__ty_from_bytes!(
 			$uint, Lsb0, [$($crate::macros::internal::u8_from_le_bits(
 				$a != 0, $b != 0, $c != 0, $d != 0,
 				$e != 0, $f != 0, $g != 0, $h != 0,
 			)),*]
 		);
 		$crate::mem::BitElement::<$typ>::new(ELEM $(as $usz)?).elem
 	}};
 	($typ:ty as $uint:ident $(as $usz:ident)?, Msb0; $(
 		$a:expr, $b:expr, $c:expr, $d:expr,
 		$e:expr, $f:expr, $g:expr, $h:expr,
 	)*) => {{
 		const ELEM: $uint = $crate::__ty_from_bytes!(
 			$uint, Msb0, [$($crate::macros::internal::u8_from_be_bits(
 				$a != 0, $b != 0, $c != 0, $d != 0,
 				$e != 0, $f != 0, $g != 0, $h != 0,
 			)),*]
 		);
 		$crate::mem::BitElement::<$typ>::new(ELEM $(as $usz)?).elem
 	}};
 	($typ:ty as $uint:ident $(as $usz:ident)?, LocalBits; $(
 		$a:expr, $b:expr, $c:expr, $d:expr,
 		$e:expr, $f:expr, $g:expr, $h:expr,
 	)*) => {{
 		const ELEM: $uint = $crate::__ty_from_bytes!(
 			$uint, LocalBits, [$($crate::macros::internal::u8_from_ne_bits(
 				$a != 0, $b != 0, $c != 0, $d != 0,
 				$e != 0, $f != 0, $g != 0, $h != 0,
 			)),*]
 		);
 		$crate::mem::BitElement::<$typ>::new(ELEM $(as $usz)?).elem
 	}};
 	//  Otherwise, invoke `BitOrder` for each bit and accumulate.
 	($typ:ty as $uint:ident $(as $usz:ident)?, $ord:tt; $($bit:expr),* $(,)?) => {{
 		let mut tmp: $uint = 0;
 		let _bits = $crate::slice::BitSlice::<$uint, $ord>::from_element_mut(
 			&mut tmp
 		);
 		let mut _idx = 0;
 		$( _bits.set(_idx, $bit != 0); _idx += 1; )*
 		$crate::mem::BitElement::<$typ>::new(tmp $(as $usz)?).elem
 	}};
 }

 /// Translates `false` into `0` and `true` into `!0`.
 #[doc(hidden)]
 #[macro_export]
 macro_rules! __extend_bool {
 	($val:expr, $typ:tt) => {{
 		type Mem = <$typ as $crate::store::BitStore>::Mem;
 		if $val != 0 {
 			<Mem as $crate::mem::BitRegister>::ALL
 		}
 		else {
 			<Mem as $crate::macros::internal::funty::Integral>::ZERO
 		}
 	}};
 }

 /// Constructs an unsigned integer from a list of *bytes*.
 #[doc(hidden)]
 #[macro_export]
 macro_rules! __ty_from_bytes {
 	(u8, Msb0, [$($byte:expr),*]) => {
 		u8::from_be_bytes([$($byte),*])
 	};
 	(u8, Lsb0, [$($byte:expr),*]) => {
 		u8::from_le_bytes([$($byte),*])
 	};
 	(u8, LocalBits, [$($byte:expr),*]) => {
 		u8::from_ne_bytes([$($byte),*])
 	};
 	(u16, Msb0, [$($byte:expr),*]) => {
 		u16::from_be_bytes([$($byte),*])
 	};
 	(u16, Lsb0, [$($byte:expr),*]) => {
 		u16::from_le_bytes([$($byte),*])
 	};
 	(u16, LocalBits, [$($byte:expr),*]) => {
 		u16::from_ne_bytes([$($byte),*])
 	};
 	(u32, Msb0, [$($byte:expr),*]) => {
 		u32::from_be_bytes([$($byte),*])
 	};
 	(u32, Lsb0, [$($byte:expr),*]) => {
 		u32::from_le_bytes([$($byte),*])
 	};
 	(u32, LocalBits, [$($byte:expr),*]) => {
 		u32::from_ne_bytes([$($byte),*])
 	};
 	(u64, Msb0, [$($byte:expr),*]) => {
 		u64::from_be_bytes([$($byte),*])
 	};
 	(u64, Lsb0, [$($byte:expr),*]) => {
 		u64::from_le_bytes([$($byte),*])
 	};
 	(u64, LocalBits, [$($byte:expr),*]) => {
 		u64::from_ne_bytes([$($byte),*])
 	};
 	(usize, Msb0, [$($byte:expr),*]) => {
 		usize::from_be_bytes([$($byte),*])
 	};
 	(usizeLsb0, , [$($byte:expr),*]) => {
 		usize::from_le_bytes([$($byte),*])
 	};
 	(usize, LocalBits, [$($byte:expr),*]) => {
 		usize::from_ne_bytes([$($byte),*])
 	};
 }

 /// Constructs a `u8` from bits applied in `Lsb0` order (`a` low, `h` high).
 #[doc(hidden)]
 #[inline(always)]
 #[cfg(not(tarpaulin_include))]
 pub const fn u8_from_le_bits(
 	a: bool,
 	b: bool,
 	c: bool,
 	d: bool,
 	e: bool,
 	f: bool,
 	g: bool,
 	h: bool,
 ) -> u8 {
 	(a as u8)
 		| ((b as u8) << 1)
 		| ((c as u8) << 2)
 		| ((d as u8) << 3)
 		| ((e as u8) << 4)
 		| ((f as u8) << 5)
 		| ((g as u8) << 6)
 		| ((h as u8) << 7)
 }

 /// Constructs a `u8` from bits applied in `Msb0` order (`a` high, `h` low).
 #[doc(hidden)]
 #[inline(always)]
 #[cfg(not(tarpaulin_include))]
 pub const fn u8_from_be_bits(
 	a: bool,
 	b: bool,
 	c: bool,
 	d: bool,
 	e: bool,
 	f: bool,
 	g: bool,
 	h: bool,
 ) -> u8 {
 	(h as u8)
 		| ((g as u8) << 1)
 		| ((f as u8) << 2)
 		| ((e as u8) << 3)
 		| ((d as u8) << 4)
 		| ((c as u8) << 5)
 		| ((b as u8) << 6)
 		| ((a as u8) << 7)
 }

 #[doc(hidden)]
 #[cfg(target_endian = "big")]
 pub use self::u8_from_be_bits as u8_from_ne_bits;
 #[doc(hidden)]
 #[cfg(target_endian = "little")]
 pub use self::u8_from_le_bits as u8_from_ne_bits;
	#![doc(hidden)]
	#![doc = include_str!("../../doc/macros/internal.md")]

	// Provide known mount-points of dependency crates.

	#[doc(hidden)]
	pub use core;

	#[doc(hidden)]
	pub use funty;

	#[doc(hidden)]
	#[macro_export]
	#[doc = include_str!("../../doc/macros/encode_bits.md")]
	macro_rules! __encode_bits {
	/* ENTRY POINTS
	*
	* These arms match the syntax provided by the public macros, and dispatch
	* by storage type width.
	*/

	(u8, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(u8 as u8, $ord; $($val),*)
	};
	(Cell<u8>, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(Cell<u8> as u8, $ord; $($val),*)
	};
	(AtomicU8, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(AtomicU8 as u8, $ord; $($val),*)
	};
	(RadiumU8, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(RadiumU8 as u8, $ord; $($val),*)
	};

	(u16, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(u16 as u16, $ord; $($val),*)
	};
	(Cell<u16>, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(Cell<u16> as u16, $ord; $($val),*)
	};
	(AtomicU16, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(AtomicU16 as u16, $ord; $($val),*)
	};
	(RadiumU16, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(RadiumU16 as u16, $ord; $($val),*)
	};

	(u32, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(u32 as u32, $ord; $($val),*)
	};
	(Cell<u32>, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(Cell<u32> as u32, $ord; $($val),*)
	};
	(AtomicU32, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(AtomicU32 as u32, $ord; $($val),*)
	};
	(RadiumU32, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(RadiumU32 as u32, $ord; $($val),*)
	};

	(u64, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(u64 as u64, $ord; $($val),*)
	};
	(Cell<u64>, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(Cell<u64> as u64, $ord; $($val),*)
	};
	(AtomicU64, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(AtomicU64 as u64, $ord; $($val),*)
	};
	(RadiumU64, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(RadiumU64 as u64, $ord; $($val),*)
	};

	(usize, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(usize as usize, $ord; $($val),*)
	};
	(Cell<usize>, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(Cell<usize> as usize, $ord; $($val),*)
	};
	(AtomicUsize, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(AtomicUsize as usize, $ord; $($val),*)
	};
	(RadiumUsize, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(RadiumUsize as usize, $ord; $($val),*)
	};

	// This arm routes `usize` into `u32` or `u64`, depending on target, and
	// marks them to return to `usize` after chunking.
	($typ:ty as usize, $ord:tt; $($val:expr),*) => {{
	const LEN: usize = $crate::__count_elts!(usize; $($val),*);

	let out: [$typ; LEN];

	#[cfg(target_pointer_width = "32")]
	{
	out = $crate::__encode_bits!($typ as u32 as usize, $ord; $($val),*);
	}

	#[cfg(target_pointer_width = "64")]
	{
	out = $crate::__encode_bits!($typ as u64 as usize, $ord; $($val),*);
	}

	out
	}};

	// ZERO EXTENSION: Supply literal `0, ` tokens to ensure that elements can
	// be completely filled with bits.
	($typ:ty as $uint:ident $(as $usz:ident)?, $ord:tt; $($val:expr),*) => {
	$crate::__encode_bits!(
	$typ as $uint $(as $usz)?, $ord; []; $($val,)*
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 32
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 48
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 64
	)
	};

	/* EXIT POINT.
	*
	* This arm enters once the only remaining bit-expression tokens are the
	* literal `0, `s provided above. It does not enter while any opaque
	* user-provided bit expressions remain, and matching falls through to the
	* chunkers, below.
	*
	* Once entered, this converts each chunk of bit expressions into the
	* requested storage element, then emits an array of the encoded elements.
	* This array is the final value of the originally-invoked macro. The
	* invoker is responsible for turning the array into a `bitvec` type.
	*/
	(
	$typ:ty as $uint:ident as usize, $ord:tt;
	[$([$($bit:tt,)+],)]; $(0,)
	) => {
	[$($crate::__make_elem!($typ as $uint as usize, $ord; $($bit,)+),)*]
	};
	(
	$typ:ty as $uint:ident, $ord:tt;
	[$([$($bit:tt,)+],)]; $(0,)
	) => {
	[$($crate::__make_elem!($typ as $uint, $ord; $($bit,)+),)*]
	};

	/* CHUNKERS
	*
	* These arms munch through the token stream, creating a sequence of chunks
	* of bits. Each chunk contains bits to exactly fill one element, and gets
	* passed into `__make_elem!` for final encoding.
	*/

	(
	$typ:ty as u8, $ord:tt; [$($elem:tt)*];
	$a0:tt, $b0:tt, $c0:tt, $d0:tt, $e0:tt, $f0:tt, $g0:tt, $h0:tt,
	$($t:tt)*
	) => {
	$crate::__encode_bits!(
	$typ as u8, $ord; [$($elem)* [
	$a0, $b0, $c0, $d0, $e0, $f0, $g0, $h0,
	],]; $($t)*
	)
	};

	(
	$typ:ty as u16, $ord:tt; [$($elem:tt)*];
	$a0:tt, $b0:tt, $c0:tt, $d0:tt, $e0:tt, $f0:tt, $g0:tt, $h0:tt,
	$a1:tt, $b1:tt, $c1:tt, $d1:tt, $e1:tt, $f1:tt, $g1:tt, $h1:tt,
	$($t:tt)*
	) => {
	$crate::__encode_bits!(
	$typ as u16, $ord; [$($elem)* [
	$a0, $b0, $c0, $d0, $e0, $f0, $g0, $h0,
	$a1, $b1, $c1, $d1, $e1, $f1, $g1, $h1,
	],]; $($t)*
	)
	};

	(
	$typ:ty as u32 $(as $usz:ident)?, $ord:tt; [$($elem:tt)*];
	$a0:tt, $b0:tt, $c0:tt, $d0:tt, $e0:tt, $f0:tt, $g0:tt, $h0:tt,
	$a1:tt, $b1:tt, $c1:tt, $d1:tt, $e1:tt, $f1:tt, $g1:tt, $h1:tt,
	$a2:tt, $b2:tt, $c2:tt, $d2:tt, $e2:tt, $f2:tt, $g2:tt, $h2:tt,
	$a3:tt, $b3:tt, $c3:tt, $d3:tt, $e3:tt, $f3:tt, $g3:tt, $h3:tt,
	$($t:tt)*
	) => {
	$crate::__encode_bits!(
	$typ as u32 $(as $usz)?, $ord; [$($elem)* [
	$a0, $b0, $c0, $d0, $e0, $f0, $g0, $h0,
	$a1, $b1, $c1, $d1, $e1, $f1, $g1, $h1,
	$a2, $b2, $c2, $d2, $e2, $f2, $g2, $h2,
	$a3, $b3, $c3, $d3, $e3, $f3, $g3, $h3,
	],]; $($t)*
	)
	};

	(
	$typ:ty as u64 $(as $usz:ident)?, $ord:tt; [$($elem:tt)*];
	$a0:tt, $b0:tt, $c0:tt, $d0:tt, $e0:tt, $f0:tt, $g0:tt, $h0:tt,
	$a1:tt, $b1:tt, $c1:tt, $d1:tt, $e1:tt, $f1:tt, $g1:tt, $h1:tt,
	$a2:tt, $b2:tt, $c2:tt, $d2:tt, $e2:tt, $f2:tt, $g2:tt, $h2:tt,
	$a3:tt, $b3:tt, $c3:tt, $d3:tt, $e3:tt, $f3:tt, $g3:tt, $h3:tt,
	$a4:tt, $b4:tt, $c4:tt, $d4:tt, $e4:tt, $f4:tt, $g4:tt, $h4:tt,
	$a5:tt, $b5:tt, $c5:tt, $d5:tt, $e5:tt, $f5:tt, $g5:tt, $h5:tt,
	$a6:tt, $b6:tt, $c6:tt, $d6:tt, $e6:tt, $f6:tt, $g6:tt, $h6:tt,
	$a7:tt, $b7:tt, $c7:tt, $d7:tt, $e7:tt, $f7:tt, $g7:tt, $h7:tt,
	$($t:tt)*
	) => {
	$crate::__encode_bits!(
	$typ as u64 $(as $usz)?, $ord; [$($elem)* [
	$a0, $b0, $c0, $d0, $e0, $f0, $g0, $h0,
	$a1, $b1, $c1, $d1, $e1, $f1, $g1, $h1,
	$a2, $b2, $c2, $d2, $e2, $f2, $g2, $h2,
	$a3, $b3, $c3, $d3, $e3, $f3, $g3, $h3,
	$a4, $b4, $c4, $d4, $e4, $f4, $g4, $h4,
	$a5, $b5, $c5, $d5, $e5, $f5, $g5, $h5,
	$a6, $b6, $c6, $d6, $e6, $f6, $g6, $h6,
	$a7, $b7, $c7, $d7, $e7, $f7, $g7, $h7,
	],]; $($t)*
	)
	};
	}

	/// Counts the number of expression tokens in a repetition sequence.
	#[doc(hidden)]
	#[macro_export]
	macro_rules! __count {
	(@ $val:expr) => { 1 };
	($($val:expr),* $(,)?) => {{
	const LEN: usize = 0 $(+ $crate::__count!(@ $val))*;
	LEN
	}};
	}

	/// Counts the number of storage elements needed to store a bit sequence.
	#[doc(hidden)]
	#[macro_export]
	macro_rules! __count_elts {
	($t:ty; $($val:expr),*) => {
	$crate::mem::elts::<$t>($crate::__count!($($val),*))
	};
	}

	#[doc(hidden)]
	#[macro_export]
	#[doc = include_str!("../../doc/macros/make_elem.md")]
	macro_rules! __make_elem {
	// Token-matching ordering names can use specialized work.
	($typ:ty as $uint:ident $(as $usz:ident)?, Lsb0; $(
	$a:expr, $b:expr, $c:expr, $d:expr,
	$e:expr, $f:expr, $g:expr, $h:expr,
	)*) => {{
	const ELEM: $uint = $crate::__ty_from_bytes!(
	$uint, Lsb0, [$($crate::macros::internal::u8_from_le_bits(
	$a != 0, $b != 0, $c != 0, $d != 0,
	$e != 0, $f != 0, $g != 0, $h != 0,
	)),*]
	);
	$crate::mem::BitElement::<$typ>::new(ELEM $(as $usz)?).elem
	}};
	($typ:ty as $uint:ident $(as $usz:ident)?, Msb0; $(
	$a:expr, $b:expr, $c:expr, $d:expr,
	$e:expr, $f:expr, $g:expr, $h:expr,
	)*) => {{
	const ELEM: $uint = $crate::__ty_from_bytes!(
	$uint, Msb0, [$($crate::macros::internal::u8_from_be_bits(
	$a != 0, $b != 0, $c != 0, $d != 0,
	$e != 0, $f != 0, $g != 0, $h != 0,
	)),*]
	);
	$crate::mem::BitElement::<$typ>::new(ELEM $(as $usz)?).elem
	}};
	($typ:ty as $uint:ident $(as $usz:ident)?, LocalBits; $(
	$a:expr, $b:expr, $c:expr, $d:expr,
	$e:expr, $f:expr, $g:expr, $h:expr,
	)*) => {{
	const ELEM: $uint = $crate::__ty_from_bytes!(
	$uint, LocalBits, [$($crate::macros::internal::u8_from_ne_bits(
	$a != 0, $b != 0, $c != 0, $d != 0,
	$e != 0, $f != 0, $g != 0, $h != 0,
	)),*]
	);
	$crate::mem::BitElement::<$typ>::new(ELEM $(as $usz)?).elem
	}};
	// Otherwise, invoke `BitOrder` for each bit and accumulate.
	($typ:ty as $uint:ident $(as $usz:ident)?, $ord:tt; $($bit:expr),* $(,)?) => {{
	let mut tmp: $uint = 0;
	let _bits = $crate::slice::BitSlice::<$uint, $ord>::from_element_mut(
	&mut tmp
	);
	let mut _idx = 0;
	$( _bits.set(_idx, $bit != 0); _idx += 1; )*
	$crate::mem::BitElement::<$typ>::new(tmp $(as $usz)?).elem
	}};
	}

	/// Translates `false` into `0` and `true` into `!0`.
	#[doc(hidden)]
	#[macro_export]
	macro_rules! __extend_bool {
	($val:expr, $typ:tt) => {{
	type Mem = <$typ as $crate::store::BitStore>::Mem;
	if $val != 0 {
	<Mem as $crate::mem::BitRegister>::ALL
	}
	else {
	<Mem as $crate::macros::internal::funty::Integral>::ZERO
	}
	}};
	}

	/// Constructs an unsigned integer from a list of bytes.
	#[doc(hidden)]
	#[macro_export]
	macro_rules! __ty_from_bytes {
	(u8, Msb0, [$($byte:expr),*]) => {
	u8::from_be_bytes([$($byte),*])
	};
	(u8, Lsb0, [$($byte:expr),*]) => {
	u8::from_le_bytes([$($byte),*])
	};
	(u8, LocalBits, [$($byte:expr),*]) => {
	u8::from_ne_bytes([$($byte),*])
	};
	(u16, Msb0, [$($byte:expr),*]) => {
	u16::from_be_bytes([$($byte),*])
	};
	(u16, Lsb0, [$($byte:expr),*]) => {
	u16::from_le_bytes([$($byte),*])
	};
	(u16, LocalBits, [$($byte:expr),*]) => {
	u16::from_ne_bytes([$($byte),*])
	};
	(u32, Msb0, [$($byte:expr),*]) => {
	u32::from_be_bytes([$($byte),*])
	};
	(u32, Lsb0, [$($byte:expr),*]) => {
	u32::from_le_bytes([$($byte),*])
	};
	(u32, LocalBits, [$($byte:expr),*]) => {
	u32::from_ne_bytes([$($byte),*])
	};
	(u64, Msb0, [$($byte:expr),*]) => {
	u64::from_be_bytes([$($byte),*])
	};
	(u64, Lsb0, [$($byte:expr),*]) => {
	u64::from_le_bytes([$($byte),*])
	};
	(u64, LocalBits, [$($byte:expr),*]) => {
	u64::from_ne_bytes([$($byte),*])
	};
	(usize, Msb0, [$($byte:expr),*]) => {
	usize::from_be_bytes([$($byte),*])
	};
	(usizeLsb0, , [$($byte:expr),*]) => {
	usize::from_le_bytes([$($byte),*])
	};
	(usize, LocalBits, [$($byte:expr),*]) => {
	usize::from_ne_bytes([$($byte),*])
	};
	}

	/// Constructs a `u8` from bits applied in `Lsb0` order (`a` low, `h` high).
	#[doc(hidden)]
	#[inline(always)]
	#[cfg(not(tarpaulin_include))]
	pub const fn u8_from_le_bits(
	a: bool,
	b: bool,
	c: bool,
	d: bool,
	e: bool,
	f: bool,
	g: bool,
	h: bool,
	) -> u8 {
	(a as u8)
	\| ((b as u8) << 1)
	\| ((c as u8) << 2)
	\| ((d as u8) << 3)
	\| ((e as u8) << 4)
	\| ((f as u8) << 5)
	\| ((g as u8) << 6)
	\| ((h as u8) << 7)
	}

	/// Constructs a `u8` from bits applied in `Msb0` order (`a` high, `h` low).
	#[doc(hidden)]
	#[inline(always)]
	#[cfg(not(tarpaulin_include))]
	pub const fn u8_from_be_bits(
	a: bool,
	b: bool,
	c: bool,
	d: bool,
	e: bool,
	f: bool,
	g: bool,
	h: bool,
	) -> u8 {
	(h as u8)
	\| ((g as u8) << 1)
	\| ((f as u8) << 2)
	\| ((e as u8) << 3)
	\| ((d as u8) << 4)
	\| ((c as u8) << 5)
	\| ((b as u8) << 6)
	\| ((a as u8) << 7)
	}

	#[doc(hidden)]
	#[cfg(target_endian = "big")]
	pub use self::u8_from_be_bits as u8_from_ne_bits;
	#[doc(hidden)]
	#[cfg(target_endian = "little")]
	pub use self::u8_from_le_bits as u8_from_ne_bits;