polylane 0.3.0

// Copyright 2025 Gabriel Bjørnager Jensen.
//
// This Source Code Form is subject to the terms of
// the Mozilla Public License, v. 2.0. If a copy of
// the MPL was not distributed with this file, you
// can obtain one at:
// <https://mozilla.org/MPL/2.0/>.

//! Collection of SIMD mask types.

mod test;

use crate::prelude::*;

macro_rules! def_mask {
	{
		ident:       $ident:ident,
		elm:         $elm:ident,
		len:         $len:literal,
		inner:       $inner:ty,
		pretty_size: $pretty_size:literal,
		pretty_len:  $pretty_len:expr$(,)?
	} => {
		#[doc = ::core::concat!(
			"SIMD vector mask suitable for (",
			$pretty_len,
			") ",
			$pretty_size,
			"-bit element(s).\n",
			"\n",
			"For a given SIMD vector with elements of some width, the equivalent mask type can be described as another SIMD vector of equivalently-wide, signed integers.\n",
			"That is, for example, for an [`f32x6`](::polylane::simd::f32x6) vector, the appropriate mask vector type would be [`i32x6`](::polylane::simd::i32x6).\n",
		)]
		#[repr(transparent)]
		#[derive(
			::core::clone::Clone,
			::core::marker::Copy,
			::core::default::Default,
			::core::cmp::Eq,
			::core::cmp::PartialEq,
			::core::cmp::PartialOrd,
		)]
		#[cfg_attr(
			feature = "bytemuck",
			derive(
				::bytemuck::Pod,
				::bytemuck::Zeroable,
			),
		)]
		#[cfg_attr(
			feature = "zerocopy",
			derive(
				::zerocopy::FromBytes,
				::zerocopy::IntoBytes,
				::zerocopy::KnownLayout,
			),
		)]
		pub struct $ident($inner);

		impl $ident {
			/// The lane count of the mask type.
			pub const LEN: usize = $len;

			/// Splats a given value into the elements of a SIMD mask.
			#[inline(always)]
			#[must_use]
			pub const fn splat(value: bool) -> Self {
				let mask = [value; Self::LEN];
				Self::from_array(mask)
			}

			/// Constructs a SIMD mask from an array of booleans.
			#[inline]
			#[must_use]
			pub const fn from_array(mask: [bool; Self::LEN]) -> Self {
				let mut data = [0x0; Self::LEN];

				let mut i = 0x0;
				while i < Self::LEN {
					data[i] = 0x0 - mask[i] as $elm;

					i += 0x1;
				}

				let mask = <$inner>::from_array(data);

				Self::from_int(mask)
			}

			/// Constructs a SIMD mask from a SIMD vector.
			///
			/// See [from_int_unchecked](Self::from_int_unchecked) for this operation without checks.
			///
			/// # Panics
			///
			/// All values of the SIMD vector `v` must either be `0` (mask does not apply) or `-1` (mask applies).
			/// If this is not the case, then this constructor will panic.
			#[inline]
			#[must_use]
			pub const fn from_int(v: $inner) -> Self {
				let mut i = 0x0;
				while i < <$inner>::LEN {
					let mask_element = v.as_array()[i];

					assert!(
						mask_element == 0x0 || mask_element == -0x1,
						"mask elements must either be `0` or `-1`",
					);

					i += 0x1;
				}

				// SAFETY: We have verified the data.
				unsafe { Self::from_int_unchecked(v) }
			}

			/// Constructs a SIMD mask from a SIMD vector.
			///
			/// See [from_int](Self::from_int) for a safe variant of this function.
			///
			/// # Safety
			///
			/// All values of the SIMD vector `v` must either be `0` (mask does not apply) or `-1` (mask applies).
			/// Behaviour is undefined if this is not the case.
			#[inline(always)]
			#[must_use]
			pub const unsafe fn from_int_unchecked(v: $inner) -> Self {
				Self(v)
			}

			/// Converts a bitmask to a SIMD mask.
			///
			/// For each bit `v` of `bitmask`, the value of `v` as a boolean is written into the SIMD mask at the bit index of `v`
			/// For each bit where its index is greater than [`Self::LEN`], the value is ignored.
			#[must_use]
			pub const fn from_bitmask(bitmask: u32) -> Self {
				let mut this = Self::splat(false);

				let mut i = 0x0;
				while i < Self::LEN {
					let value = bitmask >> i == 0x0;
					this.set(i, value);

					i += 0x1;
				}

				this
			}

			/// Sets a specific element of the mask.
			///
			/// # Panics
			///
			/// If `index` is outside the bounds of the vector, then this function will panic.
			#[inline(always)]
			pub const fn set(&mut self, index: usize, value: bool) {
				assert!(
					index < Self::LEN,
					"cannot set mask element past length",
				);

				// SAFETY: The index has been tested to be within
				// bounds.
				unsafe { self.set_unchecked(index, value) };
			}

			/// Unsafely sets a specific element of the mask.
			///
			/// # Safety
			///
			/// The provided index must be within bounds of the SIMD mask.
			#[inline(always)]
			pub const unsafe fn set_unchecked(&mut self, index: usize, value: bool) {
				debug_assert!(index < Self::LEN);

				let value = 0x0 - value as $elm;

				let slot = unsafe { &mut self.as_int_mut().as_mut_array()[index] };

				*slot = value;
			}

			/// Tests a specific element of the mask.
			///
			/// # Panics
			///
			/// If `index` is outside the bounds of the vector, then this function will panic.
			#[inline]
			#[track_caller]
			#[must_use]
			pub const fn test(self, index: usize) -> bool {
				assert!(
					index < Self::LEN,
					"cannot test mask element past length",
				);

				// SAFETY: The index has been tested to be within
				// bounds.
				unsafe { self.test_unchecked(index) }
			}

			/// Unsafely tests a specific element of the mask.
			///
			/// # Safety
			///
			/// The provided index must be within bounds of the SIMD mask.
			#[inline]
			#[must_use]
			pub const unsafe fn test_unchecked(self, index: usize) -> bool {
				debug_assert!(index < Self::LEN);

				let value = self.as_int().as_array()[index];
				value == -0x1
			}

			/// Test if the mask applies to any element at all.
			#[inline]
			#[must_use]
			pub const fn any(self) -> bool {
				let mut i = 0x0;
				while i < Self::LEN {
					if self.test(i) {
						return true;
					}

					i += 0x1;
				}

				false
			}

			/// Test if the mask applies to all element at once.
			#[inline]
			#[must_use]
			pub const fn all(self) -> bool {
				let mut i = 0x0;
				while i < Self::LEN {
					if !self.test(i) {
						return false;
					}

					i += 0x1;
				}

				true
			}

			/// Retrieves the length of the SIMD mask.
			///
			/// The returned value is always equal to [`Self::LEN`].
			#[expect(clippy::len_without_is_empty)]
			#[inline(always)]
			#[must_use]
			pub const fn len(&self) -> usize {
				Self::LEN
			}

			/// Reinterprets the SIMD mask as a SIMD vector.
			#[inline(always)]
			#[must_use]
			pub const fn as_int(&self) -> &$inner {
				&self.0
			}

			/// Reinterprets the SIMD mask as a mutable SIMD vector.
			///
			/// # Safety
			///
			/// Modifications to the vector may not yield values other than `0` or `-1`.
			#[inline(always)]
			#[must_use]
			pub const unsafe fn as_int_mut(&mut self) -> &mut $inner {
				&mut self.0
			}

			/// Converts the SIMD mask into an array of booleans.
			///
			/// For each value in the initial mask, `0` values are converted to `false` and `-1` values are converted to `true`.
			#[inline]
			#[must_use]
			pub const fn to_array(self) -> [bool; Self::LEN] {
				let mask = self.to_int().to_array();

				let mut data = [false; Self::LEN];

				let mut i = 0x0;
				while i < Self::LEN {
					data[i] = mask[i] < 0x0;

					i += 0x1;
				}

				data
			}

			/// Converts the SIMD mask into a SIMD vector.
			///
			/// For each element of the returned vector, `0` denotes an index that the mask applies to and `-1` denotes an index that the mask does *not* apply to.
			#[inline(always)]
			#[must_use]
			pub const fn to_int(self) -> $inner {
				self.0
			}

			/// Converts the SIMD mask into a bitmask.
			///
			/// For each element index `i` of the mask, the returned bitmask will have its own, equivalent bit index set to the value of the mask element at `i`.
			#[must_use]
			pub const fn to_bitmask(self) -> u32 {
				let mut bitmask = 0b00000000_00000000_00000000_00000000;

				let mut i = 0x0;
				while i < Self::LEN {
					let value = self.test(i) as u32;
					bitmask |= value << i;

					i += 0x1;
				}

				bitmask
			}
		}

		impl ::core::fmt::Debug for $ident {
			#[inline]
			fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
				use ::polylane::SealedMaskElement;

				let entries = self
					.as_int()
					.iter()
					.map(|value| value.test());

				f.debug_list().entries(entries).finish()
			}
		}

		impl ::core::convert::From<[bool; Self::LEN]> for $ident {
			/// See [`from_array`](Self::from_array).
			#[inline(always)]
			fn from(value: [bool; Self::LEN]) -> Self {
				Self::from_array(value)
			}
		}

		impl ::core::convert::TryFrom<$inner> for $ident {
			type Error = ::polylane::MaskTryFromIntError<$elm>;

			#[inline]
			fn try_from(value: $inner) -> Result<Self, Self::Error> {
				for (i, v) in value.iter().enumerate() {
					if *v != 0x0 && *v != -0x1 {
						let e = ::polylane::MaskTryFromIntError {
							index: i,
							value: *v,
						};

						return Err(e);
					}
				}

				// SAFETY: We have verified the data.
				let this = unsafe { Self::from_int_unchecked(value) };
				Ok(this)
			}
		}
	};
}

def_mask! {
	ident:       Mask8x1,
	elm:         i8,
	len:         0x1,
	inner:       i8x1,
	pretty_size: "8",
	pretty_len:  "1",
}

def_mask! {
	ident:       Mask8x2,
	elm:         i8,
	len:         0x2,
	inner:       i8x2,
	pretty_size: "8",
	pretty_len:  "2",
}

def_mask! {
	ident:       Mask8x3,
	elm:         i8,
	len:         0x3,
	inner:       i8x3,
	pretty_size: "8",
	pretty_len:  "3",
}

def_mask! {
	ident:       Mask8x4,
	elm:         i8,
	len:         0x4,
	inner:       i8x4,
	pretty_size: "8",
	pretty_len:  "4",
}

def_mask! {
	ident:       Mask8x5,
	elm:         i8,
	len:         0x5,
	inner:       i8x5,
	pretty_size: "8",
	pretty_len:  "5",
}

def_mask! {
	ident:       Mask8x6,
	elm:         i8,
	len:         0x6,
	inner:       i8x6,
	pretty_size: "8",
	pretty_len:  "6",
}

def_mask! {
	ident:       Mask8x7,
	elm:         i8,
	len:         0x7,
	inner:       i8x7,
	pretty_size: "8",
	pretty_len:  "7",
}

def_mask! {
	ident:       Mask8x8,
	elm:         i8,
	len:         0x8,
	inner:       i8x8,
	pretty_size: "8",
	pretty_len:  "8",
}

def_mask! {
	ident:       Mask8x9,
	elm:         i8,
	len:         0x9,
	inner:       i8x9,
	pretty_size: "8",
	pretty_len:  "9",
}

def_mask! {
	ident:       Mask8x10,
	elm:         i8,
	len:         0xA,
	inner:       i8x10,
	pretty_size: "8",
	pretty_len:  "10",
}

def_mask! {
	ident:       Mask8x11,
	elm:         i8,
	len:         0xB,
	inner:       i8x11,
	pretty_size: "8",
	pretty_len:  "11",
}

def_mask! {
	ident:       Mask8x12,
	elm:         i8,
	len:         0xC,
	inner:       i8x12,
	pretty_size: "8",
	pretty_len:  "12",
}

def_mask! {
	ident:       Mask8x13,
	elm:         i8,
	len:         0xD,
	inner:       i8x13,
	pretty_size: "8",
	pretty_len:  "13",
}

def_mask! {
	ident:       Mask8x14,
	elm:         i8,
	len:         0xE,
	inner:       i8x14,
	pretty_size: "8",
	pretty_len:  "14",
}

def_mask! {
	ident:       Mask8x15,
	elm:         i8,
	len:         0xF,
	inner:       i8x15,
	pretty_size: "8",
	pretty_len:  "15",
}

def_mask! {
	ident:       Mask8x16,
	elm:         i8,
	len:         0x10,
	inner:       i8x16,
	pretty_size: "8",
	pretty_len:  "16",
}

def_mask! {
	ident:       Mask8x17,
	elm:         i8,
	len:         0x11,
	inner:       i8x17,
	pretty_size: "8",
	pretty_len:  "17",
}

def_mask! {
	ident:       Mask8x18,
	elm:         i8,
	len:         0x12,
	inner:       i8x18,
	pretty_size: "8",
	pretty_len:  "18",
}

def_mask! {
	ident:       Mask8x19,
	elm:         i8,
	len:         0x13,
	inner:       i8x19,
	pretty_size: "8",
	pretty_len:  "19",
}

def_mask! {
	ident:       Mask8x20,
	elm:         i8,
	len:         0x14,
	inner:       i8x20,
	pretty_size: "8",
	pretty_len:  "20",
}

def_mask! {
	ident:       Mask8x21,
	elm:         i8,
	len:         0x15,
	inner:       i8x21,
	pretty_size: "8",
	pretty_len:  "21",
}

def_mask! {
	ident:       Mask8x22,
	elm:         i8,
	len:         0x16,
	inner:       i8x22,
	pretty_size: "8",
	pretty_len:  "22",
}

def_mask! {
	ident:       Mask8x23,
	elm:         i8,
	len:         0x17,
	inner:       i8x23,
	pretty_size: "8",
	pretty_len:  "23",
}

def_mask! {
	ident:       Mask8x24,
	elm:         i8,
	len:         0x18,
	inner:       i8x24,
	pretty_size: "8",
	pretty_len:  "24",
}

def_mask! {
	ident:       Mask8x25,
	elm:         i8,
	len:         0x19,
	inner:       i8x25,
	pretty_size: "8",
	pretty_len:  "25",
}

def_mask! {
	ident:       Mask8x26,
	elm:         i8,
	len:         0x1A,
	inner:       i8x26,
	pretty_size: "8",
	pretty_len:  "26",
}

def_mask! {
	ident:       Mask8x27,
	elm:         i8,
	len:         0x1B,
	inner:       i8x27,
	pretty_size: "8",
	pretty_len:  "27",
}

def_mask! {
	ident:       Mask8x28,
	elm:         i8,
	len:         0x1C,
	inner:       i8x28,
	pretty_size: "8",
	pretty_len:  "28",
}

def_mask! {
	ident:       Mask8x29,
	elm:         i8,
	len:         0x1D,
	inner:       i8x29,
	pretty_size: "8",
	pretty_len:  "29",
}

def_mask! {
	ident:       Mask8x30,
	elm:         i8,
	len:         0x1E,
	inner:       i8x30,
	pretty_size: "8",
	pretty_len:  "30",
}

def_mask! {
	ident:       Mask8x31,
	elm:         i8,
	len:         0x1F,
	inner:       i8x31,
	pretty_size: "8",
	pretty_len:  "31",
}

def_mask! {
	ident:       Mask8x32,
	elm:         i8,
	len:         0x20,
	inner:       i8x32,
	pretty_size: "8",
	pretty_len:  "32",
}

def_mask! {
	ident:       Mask8x33,
	elm:         i8,
	len:         0x21,
	inner:       i8x33,
	pretty_size: "8",
	pretty_len:  "33",
}

def_mask! {
	ident:       Mask8x34,
	elm:         i8,
	len:         0x22,
	inner:       i8x34,
	pretty_size: "8",
	pretty_len:  "34",
}

def_mask! {
	ident:       Mask8x35,
	elm:         i8,
	len:         0x23,
	inner:       i8x35,
	pretty_size: "8",
	pretty_len:  "35",
}

def_mask! {
	ident:       Mask8x36,
	elm:         i8,
	len:         0x24,
	inner:       i8x36,
	pretty_size: "8",
	pretty_len:  "36",
}

def_mask! {
	ident:       Mask8x37,
	elm:         i8,
	len:         0x25,
	inner:       i8x37,
	pretty_size: "8",
	pretty_len:  "37",
}

def_mask! {
	ident:       Mask8x38,
	elm:         i8,
	len:         0x26,
	inner:       i8x38,
	pretty_size: "8",
	pretty_len:  "38",
}

def_mask! {
	ident:       Mask8x39,
	elm:         i8,
	len:         0x27,
	inner:       i8x39,
	pretty_size: "8",
	pretty_len:  "39",
}

def_mask! {
	ident:       Mask8x40,
	elm:         i8,
	len:         0x28,
	inner:       i8x40,
	pretty_size: "8",
	pretty_len:  "40",
}

def_mask! {
	ident:       Mask8x41,
	elm:         i8,
	len:         0x29,
	inner:       i8x41,
	pretty_size: "8",
	pretty_len:  "41",
}

def_mask! {
	ident:       Mask8x42,
	elm:         i8,
	len:         0x2A,
	inner:       i8x42,
	pretty_size: "8",
	pretty_len:  "42",
}

def_mask! {
	ident:       Mask8x43,
	elm:         i8,
	len:         0x2B,
	inner:       i8x43,
	pretty_size: "8",
	pretty_len:  "43",
}

def_mask! {
	ident:       Mask8x44,
	elm:         i8,
	len:         0x2C,
	inner:       i8x44,
	pretty_size: "8",
	pretty_len:  "44",
}

def_mask! {
	ident:       Mask8x45,
	elm:         i8,
	len:         0x2D,
	inner:       i8x45,
	pretty_size: "8",
	pretty_len:  "45",
}

def_mask! {
	ident:       Mask8x46,
	elm:         i8,
	len:         0x2E,
	inner:       i8x46,
	pretty_size: "8",
	pretty_len:  "46",
}

def_mask! {
	ident:       Mask8x47,
	elm:         i8,
	len:         0x2F,
	inner:       i8x47,
	pretty_size: "8",
	pretty_len:  "47",
}

def_mask! {
	ident:       Mask8x48,
	elm:         i8,
	len:         0x30,
	inner:       i8x48,
	pretty_size: "8",
	pretty_len:  "48",
}

def_mask! {
	ident:       Mask8x49,
	elm:         i8,
	len:         0x31,
	inner:       i8x49,
	pretty_size: "8",
	pretty_len:  "49",
}

def_mask! {
	ident:       Mask8x50,
	elm:         i8,
	len:         0x32,
	inner:       i8x50,
	pretty_size: "8",
	pretty_len:  "50",
}

def_mask! {
	ident:       Mask8x51,
	elm:         i8,
	len:         0x33,
	inner:       i8x51,
	pretty_size: "8",
	pretty_len:  "51",
}

def_mask! {
	ident:       Mask8x52,
	elm:         i8,
	len:         0x34,
	inner:       i8x52,
	pretty_size: "8",
	pretty_len:  "52",
}

def_mask! {
	ident:       Mask8x53,
	elm:         i8,
	len:         0x35,
	inner:       i8x53,
	pretty_size: "8",
	pretty_len:  "53",
}

def_mask! {
	ident:       Mask8x54,
	elm:         i8,
	len:         0x36,
	inner:       i8x54,
	pretty_size: "8",
	pretty_len:  "54",
}

def_mask! {
	ident:       Mask8x55,
	elm:         i8,
	len:         0x37,
	inner:       i8x55,
	pretty_size: "8",
	pretty_len:  "55",
}

def_mask! {
	ident:       Mask8x56,
	elm:         i8,
	len:         0x38,
	inner:       i8x56,
	pretty_size: "8",
	pretty_len:  "56",
}

def_mask! {
	ident:       Mask8x57,
	elm:         i8,
	len:         0x39,
	inner:       i8x57,
	pretty_size: "8",
	pretty_len:  "57",
}

def_mask! {
	ident:       Mask8x58,
	elm:         i8,
	len:         0x3A,
	inner:       i8x58,
	pretty_size: "8",
	pretty_len:  "58",
}

def_mask! {
	ident:       Mask8x59,
	elm:         i8,
	len:         0x3B,
	inner:       i8x59,
	pretty_size: "8",
	pretty_len:  "59",
}

def_mask! {
	ident:       Mask8x60,
	elm:         i8,
	len:         0x3C,
	inner:       i8x60,
	pretty_size: "8",
	pretty_len:  "60",
}

def_mask! {
	ident:       Mask8x61,
	elm:         i8,
	len:         0x3D,
	inner:       i8x61,
	pretty_size: "8",
	pretty_len:  "61",
}

def_mask! {
	ident:       Mask8x62,
	elm:         i8,
	len:         0x3E,
	inner:       i8x62,
	pretty_size: "8",
	pretty_len:  "62",
}

def_mask! {
	ident:       Mask8x63,
	elm:         i8,
	len:         0x3F,
	inner:       i8x63,
	pretty_size: "8",
	pretty_len:  "63",
}

def_mask! {
	ident:       Mask8x64,
	elm:         i8,
	len:         0x40,
	inner:       i8x64,
	pretty_size: "8",
	pretty_len:  "64",
}

def_mask! {
	ident:       Mask16x1,
	elm:         i16,
	len:         0x1,
	inner:       i16x1,
	pretty_size: "16",
	pretty_len:  "1",
}

def_mask! {
	ident:       Mask16x2,
	elm:         i16,
	len:         0x2,
	inner:       i16x2,
	pretty_size: "16",
	pretty_len:  "2",
}

def_mask! {
	ident:       Mask16x3,
	elm:         i16,
	len:         0x3,
	inner:       i16x3,
	pretty_size: "16",
	pretty_len:  "3",
}

def_mask! {
	ident:       Mask16x4,
	elm:         i16,
	len:         0x4,
	inner:       i16x4,
	pretty_size: "16",
	pretty_len:  "4",
}

def_mask! {
	ident:       Mask16x5,
	elm:         i16,
	len:         0x5,
	inner:       i16x5,
	pretty_size: "16",
	pretty_len:  "5",
}

def_mask! {
	ident:       Mask16x6,
	elm:         i16,
	len:         0x6,
	inner:       i16x6,
	pretty_size: "16",
	pretty_len:  "6",
}

def_mask! {
	ident:       Mask16x7,
	elm:         i16,
	len:         0x7,
	inner:       i16x7,
	pretty_size: "16",
	pretty_len:  "7",
}

def_mask! {
	ident:       Mask16x8,
	elm:         i16,
	len:         0x8,
	inner:       i16x8,
	pretty_size: "16",
	pretty_len:  "8",
}

def_mask! {
	ident:       Mask16x9,
	elm:         i16,
	len:         0x9,
	inner:       i16x9,
	pretty_size: "16",
	pretty_len:  "9",
}

def_mask! {
	ident:       Mask16x10,
	elm:         i16,
	len:         0xA,
	inner:       i16x10,
	pretty_size: "16",
	pretty_len:  "10",
}

def_mask! {
	ident:       Mask16x11,
	elm:         i16,
	len:         0xB,
	inner:       i16x11,
	pretty_size: "16",
	pretty_len:  "11",
}

def_mask! {
	ident:       Mask16x12,
	elm:         i16,
	len:         0xC,
	inner:       i16x12,
	pretty_size: "16",
	pretty_len:  "12",
}

def_mask! {
	ident:       Mask16x13,
	elm:         i16,
	len:         0xD,
	inner:       i16x13,
	pretty_size: "16",
	pretty_len:  "13",
}

def_mask! {
	ident:       Mask16x14,
	elm:         i16,
	len:         0xE,
	inner:       i16x14,
	pretty_size: "16",
	pretty_len:  "14",
}

def_mask! {
	ident:       Mask16x15,
	elm:         i16,
	len:         0xF,
	inner:       i16x15,
	pretty_size: "16",
	pretty_len:  "15",
}

def_mask! {
	ident:       Mask16x16,
	elm:         i16,
	len:         0x10,
	inner:       i16x16,
	pretty_size: "16",
	pretty_len:  "16",
}

def_mask! {
	ident:       Mask16x17,
	elm:         i16,
	len:         0x11,
	inner:       i16x17,
	pretty_size: "16",
	pretty_len:  "17",
}

def_mask! {
	ident:       Mask16x18,
	elm:         i16,
	len:         0x12,
	inner:       i16x18,
	pretty_size: "16",
	pretty_len:  "18",
}

def_mask! {
	ident:       Mask16x19,
	elm:         i16,
	len:         0x13,
	inner:       i16x19,
	pretty_size: "16",
	pretty_len:  "19",
}

def_mask! {
	ident:       Mask16x20,
	elm:         i16,
	len:         0x14,
	inner:       i16x20,
	pretty_size: "16",
	pretty_len:  "20",
}

def_mask! {
	ident:       Mask16x21,
	elm:         i16,
	len:         0x15,
	inner:       i16x21,
	pretty_size: "16",
	pretty_len:  "21",
}

def_mask! {
	ident:       Mask16x22,
	elm:         i16,
	len:         0x16,
	inner:       i16x22,
	pretty_size: "16",
	pretty_len:  "22",
}

def_mask! {
	ident:       Mask16x23,
	elm:         i16,
	len:         0x17,
	inner:       i16x23,
	pretty_size: "16",
	pretty_len:  "23",
}

def_mask! {
	ident:       Mask16x24,
	elm:         i16,
	len:         0x18,
	inner:       i16x24,
	pretty_size: "16",
	pretty_len:  "24",
}

def_mask! {
	ident:       Mask16x25,
	elm:         i16,
	len:         0x19,
	inner:       i16x25,
	pretty_size: "16",
	pretty_len:  "25",
}

def_mask! {
	ident:       Mask16x26,
	elm:         i16,
	len:         0x1A,
	inner:       i16x26,
	pretty_size: "16",
	pretty_len:  "26",
}

def_mask! {
	ident:       Mask16x27,
	elm:         i16,
	len:         0x1B,
	inner:       i16x27,
	pretty_size: "16",
	pretty_len:  "27",
}

def_mask! {
	ident:       Mask16x28,
	elm:         i16,
	len:         0x1C,
	inner:       i16x28,
	pretty_size: "16",
	pretty_len:  "28",
}

def_mask! {
	ident:       Mask16x29,
	elm:         i16,
	len:         0x1D,
	inner:       i16x29,
	pretty_size: "16",
	pretty_len:  "29",
}

def_mask! {
	ident:       Mask16x30,
	elm:         i16,
	len:         0x1E,
	inner:       i16x30,
	pretty_size: "16",
	pretty_len:  "30",
}

def_mask! {
	ident:       Mask16x31,
	elm:         i16,
	len:         0x1F,
	inner:       i16x31,
	pretty_size: "16",
	pretty_len:  "31",
}

def_mask! {
	ident:       Mask16x32,
	elm:         i16,
	len:         0x20,
	inner:       i16x32,
	pretty_size: "16",
	pretty_len:  "32",
}

def_mask! {
	ident:       Mask32x1,
	elm:         i32,
	len:         0x1,
	inner:       i32x1,
	pretty_size: "32",
	pretty_len:  "1",
}

def_mask! {
	ident:       Mask32x2,
	elm:         i32,
	len:         0x2,
	inner:       i32x2,
	pretty_size: "32",
	pretty_len:  "2",
}

def_mask! {
	ident:       Mask32x3,
	elm:         i32,
	len:         0x3,
	inner:       i32x3,
	pretty_size: "32",
	pretty_len:  "3",
}

def_mask! {
	ident:       Mask32x4,
	elm:         i32,
	len:         0x4,
	inner:       i32x4,
	pretty_size: "32",
	pretty_len:  "4",
}

def_mask! {
	ident:       Mask32x5,
	elm:         i32,
	len:         0x5,
	inner:       i32x5,
	pretty_size: "32",
	pretty_len:  "5",
}

def_mask! {
	ident:       Mask32x6,
	elm:         i32,
	len:         0x6,
	inner:       i32x6,
	pretty_size: "32",
	pretty_len:  "6",
}

def_mask! {
	ident:       Mask32x7,
	elm:         i32,
	len:         0x7,
	inner:       i32x7,
	pretty_size: "32",
	pretty_len:  "7",
}

def_mask! {
	ident:       Mask32x8,
	elm:         i32,
	len:         0x8,
	inner:       i32x8,
	pretty_size: "32",
	pretty_len:  "8",
}

def_mask! {
	ident:       Mask32x9,
	elm:         i32,
	len:         0x9,
	inner:       i32x9,
	pretty_size: "32",
	pretty_len:  "9",
}

def_mask! {
	ident:       Mask32x10,
	elm:         i32,
	len:         0xA,
	inner:       i32x10,
	pretty_size: "32",
	pretty_len:  "10",
}

def_mask! {
	ident:       Mask32x11,
	elm:         i32,
	len:         0xB,
	inner:       i32x11,
	pretty_size: "32",
	pretty_len:  "11",
}

def_mask! {
	ident:       Mask32x12,
	elm:         i32,
	len:         0xC,
	inner:       i32x12,
	pretty_size: "32",
	pretty_len:  "12",
}

def_mask! {
	ident:       Mask32x13,
	elm:         i32,
	len:         0xD,
	inner:       i32x13,
	pretty_size: "32",
	pretty_len:  "13",
}

def_mask! {
	ident:       Mask32x14,
	elm:         i32,
	len:         0xE,
	inner:       i32x14,
	pretty_size: "32",
	pretty_len:  "14",
}

def_mask! {
	ident:       Mask32x15,
	elm:         i32,
	len:         0xF,
	inner:       i32x15,
	pretty_size: "32",
	pretty_len:  "15",
}

def_mask! {
	ident:       Mask32x16,
	elm:         i32,
	len:         0x10,
	inner:       i32x16,
	pretty_size: "32",
	pretty_len:  "16",
}

def_mask! {
	ident:       Mask64x1,
	elm:         i64,
	len:         0x1,
	inner:       i64x1,
	pretty_size: "64",
	pretty_len:  "1",
}

def_mask! {
	ident:       Mask64x2,
	elm:         i64,
	len:         0x2,
	inner:       i64x2,
	pretty_size: "64",
	pretty_len:  "2",
}

def_mask! {
	ident:       Mask64x3,
	elm:         i64,
	len:         0x3,
	inner:       i64x3,
	pretty_size: "64",
	pretty_len:  "3",
}

def_mask! {
	ident:       Mask64x4,
	elm:         i64,
	len:         0x4,
	inner:       i64x4,
	pretty_size: "64",
	pretty_len:  "4",
}

def_mask! {
	ident:       Mask64x5,
	elm:         i64,
	len:         0x5,
	inner:       i64x5,
	pretty_size: "64",
	pretty_len:  "5",
}

def_mask! {
	ident:       Mask64x6,
	elm:         i64,
	len:         0x6,
	inner:       i64x6,
	pretty_size: "64",
	pretty_len:  "6",
}

def_mask! {
	ident:       Mask64x7,
	elm:         i64,
	len:         0x7,
	inner:       i64x7,
	pretty_size: "64",
	pretty_len:  "7",
}

def_mask! {
	ident:       Mask64x8,
	elm:         i64,
	len:         0x8,
	inner:       i64x8,
	pretty_size: "64",
	pretty_len:  "8",
}

def_mask! {
	ident:       Mask128x1,
	elm:         i128,
	len:         0x1,
	inner:       i128x1,
	pretty_size: "128",
	pretty_len:  "1",
}

def_mask! {
	ident:       Mask128x2,
	elm:         i128,
	len:         0x2,
	inner:       i128x2,
	pretty_size: "128",
	pretty_len:  "2",
}

def_mask! {
	ident:       Mask128x3,
	elm:         i128,
	len:         0x3,
	inner:       i128x3,
	pretty_size: "128",
	pretty_len:  "3",
}

def_mask! {
	ident:       Mask128x4,
	elm:         i128,
	len:         0x4,
	inner:       i128x4,
	pretty_size: "128",
	pretty_len:  "4",
}