oct 0.29.2

// Copyright 2024-2026 Gabriel Bjørnager Jensen.
//
// SPDX: MIT OR Apache-2.0

//! The [`Immutable`] trait.

use core::convert::Infallible;
use core::mem::{ManuallyDrop, MaybeUninit};
use core::num::{NonZero, Saturating, Wrapping};
use core::ptr::NonNull;

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
use core::arch::aarch64::{
	float64x1_t,
	float64x1x2_t,
	float64x1x3_t,
	float64x1x4_t,
	float64x2_t,
	float64x2x2_t,
	float64x2x3_t,
	float64x2x4_t,
};

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
use core::arch::aarch64::{
	float32x2_t,
	float32x2x2_t,
	float32x2x3_t,
	float32x2x4_t,
	float32x4_t,
	float32x4x2_t,
	float32x4x3_t,
	float32x4x4_t,
	int16x4_t,
	int16x4x2_t,
	int16x4x3_t,
	int16x4x4_t,
	int16x8_t,
	int16x8x2_t,
	int16x8x3_t,
	int16x8x4_t,
	int32x2_t,
	int32x2x2_t,
	int32x2x3_t,
	int32x2x4_t,
	int32x4_t,
	int32x4x2_t,
	int32x4x3_t,
	int32x4x4_t,
	int64x1_t,
	int64x1x2_t,
	int64x1x3_t,
	int64x1x4_t,
	int64x2_t,
	int64x2x2_t,
	int64x2x3_t,
	int64x2x4_t,
	int8x16_t,
	int8x16x2_t,
	int8x16x3_t,
	int8x16x4_t,
	int8x8_t,
	int8x8x2_t,
	int8x8x3_t,
	int8x8x4_t,
	poly16x4_t,
	poly16x4x2_t,
	poly16x4x3_t,
	poly16x4x4_t,
	poly16x8_t,
	poly16x8x2_t,
	poly16x8x3_t,
	poly16x8x4_t,
	poly32x2_t,
	poly32x2x2_t,
	poly32x2x3_t,
	poly32x2x4_t,
	poly32x4_t,
	poly32x4x2_t,
	poly32x4x3_t,
	poly32x4x4_t,
	poly64x1_t,
	poly64x1x2_t,
	poly64x1x3_t,
	poly64x1x4_t,
	poly64x2_t,
	poly64x2x2_t,
	poly64x2x3_t,
	poly64x2x4_t,
	poly8x16_t,
	poly8x16x2_t,
	poly8x16x3_t,
	poly8x16x4_t,
	poly8x8_t,
	poly8x8x2_t,
	poly8x8x3_t,
	poly8x8x4_t,
	uint16x4_t,
	uint16x4x2_t,
	uint16x4x3_t,
	uint16x4x4_t,
	uint16x8_t,
	uint16x8x2_t,
	uint16x8x3_t,
	uint16x8x4_t,
	uint32x2_t,
	uint32x2x2_t,
	uint32x2x3_t,
	uint32x2x4_t,
	uint32x4_t,
	uint32x4x2_t,
	uint32x4x3_t,
	uint32x4x4_t,
	uint64x1_t,
	uint64x1x2_t,
	uint64x1x3_t,
	uint64x1x4_t,
	uint64x2_t,
	uint64x2x2_t,
	uint64x2x3_t,
	uint64x2x4_t,
	uint8x16_t,
	uint8x16x2_t,
	uint8x16x3_t,
	uint8x16x4_t,
	uint8x8_t,
	uint8x8x2_t,
	uint8x8x3_t,
	uint8x8x4_t,
};

#[cfg(
	all(
		any(
			target_arch = "aarch64",
			target_arch = "arm64ec",
			target_feature = "v7",
		),
		feature = "f16",
	),
)]
use core::arch::aarch64::{
	float16x4_t,
	float16x4x2_t,
	float16x4x3_t,
	float16x4x4_t,
	float16x8_t,
	float16x8x2_t,
	float16x8x3_t,
	float16x8x4_t,
};

#[cfg(target_arch = "x86")]
use core::arch::x86::{
	CpuidResult,
	__m128,
	__m128bh,
	__m128d,
	__m128i,
	__m256,
	__m256bh,
	__m256d,
	__m256i,
	__m512,
	__m512bh,
	__m512d,
	__m512i,
};

#[cfg(all(target_arch = "x86", feature = "f16"))]
use core::arch::x86::{__m128h, __m256h, __m512h};

#[cfg(target_arch = "x86_64")]
use core::arch::x86_64::{
	CpuidResult,
	__m128,
	__m128bh,
	__m128d,
	__m128i,
	__m256,
	__m256bh,
	__m256d,
	__m256i,
	__m512,
	__m512bh,
	__m512d,
	__m512i,
};

#[cfg(all(target_arch = "x86_64", feature = "f16"))]
use core::arch::x86_64::{__m128h, __m256h, __m512h};

/// Denotes an interiour-immutable type.
///
/// This trait is implemented conservatively as
/// types rarely have any obvious guarantees about
/// the required invariants.
///
/// Note that this trait will be removed in favour
/// of [`core::marker::Freeze`] when the latter is
/// stabilised.
///
/// # Safety
///
/// Only types without interiour-mutability may
/// implement this trait. Types with
/// interiour-mutable fields (e.g. by
/// [`UnsafeCell`]) may still implement this trait
/// *if* the mutable behaviour is never observed on
/// constant objects.
///
/// [`UnsafeCell`]: core::cell::UnsafeCell
pub unsafe trait Immutable {}

// SORT: array
unsafe impl<T: Immutable, const N: usize> Immutable for [T; N] {}

// SAFETY: All-zeros corresponds to `\0`.
unsafe impl Immutable for char {}

// SAFETY: This structure is exhaustive and homoge-
// neous.
#[cfg(target_arch = "x86")]
unsafe impl Immutable for CpuidResult {}

// SAFETY: This structure is exhaustive and homoge-
// neous.
#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for CpuidResult {}

#[cfg(feature = "f128")]
unsafe impl Immutable for f128 {}

#[cfg(feature = "f16")]
unsafe impl Immutable for f16 {}

unsafe impl Immutable for f32 {}

unsafe impl Immutable for f64 {}

#[cfg(
	all(
		any(
			target_arch = "aarch64",
			target_arch = "arm64ec",
			target_feature = "v7",
		),
		feature = "f16",
	),
)]
unsafe impl Immutable for float16x4_t {}

#[cfg(
	all(
		any(
			target_arch = "aarch64",
			target_arch = "arm64ec",
			target_feature = "v7",
		),
		feature = "f16",
	),
)]
unsafe impl Immutable for float16x4x2_t {}

#[cfg(
	all(
		any(
			target_arch = "aarch64",
			target_arch = "arm64ec",
			target_feature = "v7",
		),
		feature = "f16",
	),
)]
unsafe impl Immutable for float16x4x3_t {}

#[cfg(
	all(
		any(
			target_arch = "aarch64",
			target_arch = "arm64ec",
			target_feature = "v7",
		),
		feature = "f16",
	),
)]
unsafe impl Immutable for float16x4x4_t {}

#[cfg(
	all(
		any(
			target_arch = "aarch64",
			target_arch = "arm64ec",
			target_feature = "v7",
		),
		feature = "f16",
	),
)]
unsafe impl Immutable for float16x8_t {}

#[cfg(
	all(
		any(
			target_arch = "aarch64",
			target_arch = "arm64ec",
			target_feature = "v7",
		),
		feature = "f16",
	),
)]
unsafe impl Immutable for float16x8x2_t {}

#[cfg(
	all(
		any(
			target_arch = "aarch64",
			target_arch = "arm64ec",
			target_feature = "v7",
		),
		feature = "f16",
	),
)]
unsafe impl Immutable for float16x8x3_t {}

#[cfg(
	all(
		any(
			target_arch = "aarch64",
			target_arch = "arm64ec",
			target_feature = "v7",
		),
		feature = "f16",
	),
)]
unsafe impl Immutable for float16x8x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for float32x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for float32x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for float32x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for float32x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for float32x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for float32x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for float32x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for float32x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Immutable for float64x1_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Immutable for float64x1x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Immutable for float64x1x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Immutable for float64x1x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Immutable for float64x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Immutable for float64x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Immutable for float64x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Immutable for float64x2x4_t {}

unsafe impl Immutable for fn() {}

unsafe impl<T> Immutable for fn(T) {}

unsafe impl<T0, T1> Immutable for fn(T0, T1) {}

unsafe impl<T0, T1, T2> Immutable for fn(T0, T1, T2) {}

unsafe impl<T0, T1, T2, T3> Immutable for fn(T0, T1, T2, T3) {}

unsafe impl<T0, T1, T2, T3, T4> Immutable for fn(T0, T1, T2, T3, T4) {}

unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for fn(T0, T1, T2, T3, T4, T5) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for fn(T0, T1, T2, T3, T4, T5, T6) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "arm")]
unsafe impl Immutable for extern "aapcs" fn() {}

#[cfg(target_arch = "arm")]
unsafe impl<T> Immutable for extern "aapcs" fn(T) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1> Immutable for extern "aapcs" fn(T0, T1) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2> Immutable for extern "aapcs" fn(T0, T1, T2) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3> Immutable for extern "aapcs" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "aapcs" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "aapcs" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "arm")]
unsafe impl Immutable for extern "aapcs-unwind" fn() {}

#[cfg(target_arch = "arm")]
unsafe impl<T> Immutable for extern "aapcs-unwind" fn(T) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1> Immutable for extern "aapcs-unwind" fn(T0, T1) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2> Immutable for extern "aapcs-unwind" fn(T0, T1, T2) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3> Immutable for extern "aapcs-unwind" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "aapcs-unwind" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

unsafe impl Immutable for extern "C" fn() {}

unsafe impl<T> Immutable for extern "C" fn(T) {}

unsafe impl<T0, T1> Immutable for extern "C" fn(T0, T1) {}

unsafe impl<T0, T1, T2> Immutable for extern "C" fn(T0, T1, T2) {}

unsafe impl<T0, T1, T2, T3> Immutable for extern "C" fn(T0, T1, T2, T3) {}

unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "C" fn(T0, T1, T2, T3, T4) {}

unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "C" fn(T0, T1, T2, T3, T4, T5) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "C" fn(T0, T1, T2, T3, T4, T5, T6) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

unsafe impl Immutable for extern "C-unwind" fn() {}

unsafe impl<T> Immutable for extern "C-unwind" fn(T) {}

unsafe impl<T0, T1> Immutable for extern "C-unwind" fn(T0, T1) {}

unsafe impl<T0, T1, T2> Immutable for extern "C-unwind" fn(T0, T1, T2) {}

unsafe impl<T0, T1, T2, T3> Immutable for extern "C-unwind" fn(T0, T1, T2, T3) {}

unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "C-unwind" fn(T0, T1, T2, T3, T4) {}

unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "C-unwind" fn(T0, T1, T2, T3, T4, T5) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for extern "cdecl" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for extern "cdecl" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for extern "cdecl" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for extern "cdecl" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for extern "cdecl" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "cdecl" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "cdecl" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for extern "cdecl-unwind" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for extern "cdecl-unwind" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for extern "cdecl-unwind" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for extern "cdecl-unwind" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for extern "cdecl-unwind" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "cdecl-unwind" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Immutable for extern "efiapi" fn() {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T> Immutable for extern "efiapi" fn(T) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1> Immutable for extern "efiapi" fn(T0, T1) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2> Immutable for extern "efiapi" fn(T0, T1, T2) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3> Immutable for extern "efiapi" fn(T0, T1, T2, T3) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "efiapi" fn(T0, T1, T2, T3, T4) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "efiapi" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for extern "fastcall" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for extern "fastcall" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for extern "fastcall" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for extern "fastcall" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for extern "fastcall" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "fastcall" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "fastcall" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for extern "fastcall-unwind" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for extern "fastcall-unwind" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for extern "fastcall-unwind" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for extern "fastcall-unwind" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for extern "fastcall-unwind" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "fastcall-unwind" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for extern "stdcall" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for extern "stdcall" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for extern "stdcall" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for extern "stdcall" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for extern "stdcall" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "stdcall" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "stdcall" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for extern "stdcall-unwind" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for extern "stdcall-unwind" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for extern "stdcall-unwind" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for extern "stdcall-unwind" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for extern "stdcall-unwind" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "stdcall-unwind" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for extern "sysv64" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for extern "sysv64" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for extern "sysv64" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for extern "sysv64" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for extern "sysv64" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "sysv64" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "sysv64" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for extern "sysv64-unwind" fn() {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T> Immutable for extern "sysv64-unwind" fn(T) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1> Immutable for extern "sysv64-unwind" fn(T0, T1) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2> Immutable for extern "sysv64-unwind" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3> Immutable for extern "sysv64-unwind" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "sysv64-unwind" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

unsafe impl Immutable for extern "system" fn() {}

unsafe impl<T> Immutable for extern "system" fn(T) {}

unsafe impl<T0, T1> Immutable for extern "system" fn(T0, T1) {}

unsafe impl<T0, T1, T2> Immutable for extern "system" fn(T0, T1, T2) {}

unsafe impl<T0, T1, T2, T3> Immutable for extern "system" fn(T0, T1, T2, T3) {}

unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "system" fn(T0, T1, T2, T3, T4) {}

unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "system" fn(T0, T1, T2, T3, T4, T5) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "system" fn(T0, T1, T2, T3, T4, T5, T6) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

unsafe impl Immutable for extern "system-unwind" fn() {}

unsafe impl<T> Immutable for extern "system-unwind" fn(T) {}

unsafe impl<T0, T1> Immutable for extern "system-unwind" fn(T0, T1) {}

unsafe impl<T0, T1, T2> Immutable for extern "system-unwind" fn(T0, T1, T2) {}

unsafe impl<T0, T1, T2, T3> Immutable for extern "system-unwind" fn(T0, T1, T2, T3) {}

unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "system-unwind" fn(T0, T1, T2, T3, T4) {}

unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "system-unwind" fn(T0, T1, T2, T3, T4, T5) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for extern "thiscall" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for extern "thiscall" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for extern "thiscall" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for extern "thiscall" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for extern "thiscall" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "thiscall" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "thiscall" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for extern "thiscall-unwind" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for extern "thiscall-unwind" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for extern "thiscall-unwind" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for extern "thiscall-unwind" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for extern "thiscall-unwind" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "thiscall-unwind" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for extern "win64" fn() {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T> Immutable for extern "win64" fn(T) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1> Immutable for extern "win64" fn(T0, T1) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2> Immutable for extern "win64" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3> Immutable for extern "win64" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "win64" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "win64" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "win64" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for extern "win64-unwind" fn() {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T> Immutable for extern "win64-unwind" fn(T) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1> Immutable for extern "win64-unwind" fn(T0, T1) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2> Immutable for extern "win64-unwind" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3> Immutable for extern "win64-unwind" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for extern "win64-unwind" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

unsafe impl Immutable for unsafe fn() {}

unsafe impl<T> Immutable for unsafe fn(T) {}

unsafe impl<T0, T1> Immutable for unsafe fn(T0, T1) {}

unsafe impl<T0, T1, T2> Immutable for unsafe fn(T0, T1, T2) {}

unsafe impl<T0, T1, T2, T3> Immutable for unsafe fn(T0, T1, T2, T3) {}

unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe fn(T0, T1, T2, T3, T4) {}

unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe fn(T0, T1, T2, T3, T4, T5) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe fn(T0, T1, T2, T3, T4, T5, T6) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "arm")]
unsafe impl Immutable for unsafe extern "aapcs" fn() {}

#[cfg(target_arch = "arm")]
unsafe impl<T> Immutable for unsafe extern "aapcs" fn(T) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1> Immutable for unsafe extern "aapcs" fn(T0, T1) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2> Immutable for unsafe extern "aapcs" fn(T0, T1, T2) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "aapcs" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "aapcs" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "aapcs" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "arm")]
unsafe impl Immutable for unsafe extern "aapcs-unwind" fn() {}

#[cfg(target_arch = "arm")]
unsafe impl<T> Immutable for unsafe extern "aapcs-unwind" fn(T) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1> Immutable for unsafe extern "aapcs-unwind" fn(T0, T1) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2> Immutable for unsafe extern "aapcs-unwind" fn(T0, T1, T2) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

unsafe impl Immutable for unsafe extern "C" fn() {}

unsafe impl<T> Immutable for unsafe extern "C" fn(T) {}

unsafe impl<T0, T1> Immutable for unsafe extern "C" fn(T0, T1) {}

unsafe impl<T0, T1, T2> Immutable for unsafe extern "C" fn(T0, T1, T2) {}

unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "C" fn(T0, T1, T2, T3) {}

unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "C" fn(T0, T1, T2, T3, T4) {}

unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "C" fn(T0, T1, T2, T3, T4, T5) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "C" fn(T0, T1, T2, T3, T4, T5, T6) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

unsafe impl Immutable for unsafe extern "C-unwind" fn() {}

unsafe impl<T> Immutable for unsafe extern "C-unwind" fn(T) {}

unsafe impl<T0, T1> Immutable for unsafe extern "C-unwind" fn(T0, T1) {}

unsafe impl<T0, T1, T2> Immutable for unsafe extern "C-unwind" fn(T0, T1, T2) {}

unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "C-unwind" fn(T0, T1, T2, T3) {}

unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4) {}

unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4, T5) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for unsafe extern "cdecl" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for unsafe extern "cdecl" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for unsafe extern "cdecl" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for unsafe extern "cdecl" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "cdecl" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "cdecl" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "cdecl" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for unsafe extern "cdecl-unwind" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for unsafe extern "cdecl-unwind" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for unsafe extern "cdecl-unwind" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for unsafe extern "cdecl-unwind" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Immutable for unsafe extern "efiapi" fn() {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T> Immutable for unsafe extern "efiapi" fn(T) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1> Immutable for unsafe extern "efiapi" fn(T0, T1) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2> Immutable for unsafe extern "efiapi" fn(T0, T1, T2) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "efiapi" fn(T0, T1, T2, T3) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "efiapi" fn(T0, T1, T2, T3, T4) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "efiapi" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for unsafe extern "fastcall" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for unsafe extern "fastcall" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for unsafe extern "fastcall" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for unsafe extern "fastcall" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "fastcall" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "fastcall" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "fastcall" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for unsafe extern "fastcall-unwind" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for unsafe extern "fastcall-unwind" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for unsafe extern "fastcall-unwind" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for unsafe extern "fastcall-unwind" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for unsafe extern "stdcall" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for unsafe extern "stdcall" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for unsafe extern "stdcall" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for unsafe extern "stdcall" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "stdcall" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "stdcall" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "stdcall" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for unsafe extern "stdcall-unwind" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for unsafe extern "stdcall-unwind" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for unsafe extern "stdcall-unwind" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for unsafe extern "stdcall-unwind" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for unsafe extern "sysv64" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for unsafe extern "sysv64" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for unsafe extern "sysv64" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for unsafe extern "sysv64" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "sysv64" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "sysv64" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "sysv64" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for unsafe extern "sysv64-unwind" fn() {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T> Immutable for unsafe extern "sysv64-unwind" fn(T) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1> Immutable for unsafe extern "sysv64-unwind" fn(T0, T1) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2> Immutable for unsafe extern "sysv64-unwind" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

unsafe impl Immutable for unsafe extern "system" fn() {}

unsafe impl<T> Immutable for unsafe extern "system" fn(T) {}

unsafe impl<T0, T1> Immutable for unsafe extern "system" fn(T0, T1) {}

unsafe impl<T0, T1, T2> Immutable for unsafe extern "system" fn(T0, T1, T2) {}

unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "system" fn(T0, T1, T2, T3) {}

unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "system" fn(T0, T1, T2, T3, T4) {}

unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "system" fn(T0, T1, T2, T3, T4, T5) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "system" fn(T0, T1, T2, T3, T4, T5, T6) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

unsafe impl Immutable for unsafe extern "system-unwind" fn() {}

unsafe impl<T> Immutable for unsafe extern "system-unwind" fn(T) {}

unsafe impl<T0, T1> Immutable for unsafe extern "system-unwind" fn(T0, T1) {}

unsafe impl<T0, T1, T2> Immutable for unsafe extern "system-unwind" fn(T0, T1, T2) {}

unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "system-unwind" fn(T0, T1, T2, T3) {}

unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4) {}

unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4, T5) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for unsafe extern "thiscall" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for unsafe extern "thiscall" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for unsafe extern "thiscall" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for unsafe extern "thiscall" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "thiscall" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "thiscall" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "thiscall" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for unsafe extern "thiscall-unwind" fn() {}

#[cfg(target_arch = "x86")]
unsafe impl<T> Immutable for unsafe extern "thiscall-unwind" fn(T) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Immutable for unsafe extern "thiscall-unwind" fn(T0, T1) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Immutable for unsafe extern "thiscall-unwind" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for unsafe extern "win64" fn() {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T> Immutable for unsafe extern "win64" fn(T) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1> Immutable for unsafe extern "win64" fn(T0, T1) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2> Immutable for unsafe extern "win64" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "win64" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "win64" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "win64" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "win64" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for unsafe extern "win64-unwind" fn() {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T> Immutable for unsafe extern "win64-unwind" fn(T) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1> Immutable for unsafe extern "win64-unwind" fn(T0, T1) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2> Immutable for unsafe extern "win64-unwind" fn(T0, T1, T2) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3> Immutable for unsafe extern "win64-unwind" fn(T0, T1, T2, T3) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4> Immutable for unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {}

#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {}

unsafe impl Immutable for i128 {}

unsafe impl Immutable for i16 {}

unsafe impl Immutable for i32 {}

unsafe impl Immutable for i64 {}

unsafe impl Immutable for i8 {}

// SAFETY: `Infallible` cannot be constructed.
unsafe impl Immutable for Infallible {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int16x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int16x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int16x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int16x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int16x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int16x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int16x8x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int32x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int32x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int32x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int32x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int32x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int32x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int32x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int32x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int64x1_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int64x1x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int64x1x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int64x1x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int64x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int64x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int64x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int64x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int8x16_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int8x16x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int8x16x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int8x16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int8x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int8x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int8x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for int8x8x4_t {}

unsafe impl Immutable for isize {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for __m128 {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for __m128 {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for __m128bh {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for __m128bh {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for __m128d {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for __m128d {}

#[cfg(all(target_arch = "x86", feature = "f16"))]
unsafe impl Immutable for __m128h {}

#[cfg(all(target_arch = "x86_64", feature = "f16"))]
unsafe impl Immutable for __m128h {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for __m128i {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for __m128i {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for __m256 {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for __m256 {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for __m256bh {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for __m256bh {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for __m256d {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for __m256d {}

#[cfg(all(target_arch = "x86", feature = "f16"))]
unsafe impl Immutable for __m256h {}

#[cfg(all(target_arch = "x86_64", feature = "f16"))]
unsafe impl Immutable for __m256h {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for __m256i {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for __m256i {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for __m512 {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for __m512 {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for __m512bh {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for __m512bh {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for __m512d {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for __m512d {}

#[cfg(all(target_arch = "x86", feature = "f16"))]
unsafe impl Immutable for __m512h {}

#[cfg(all(target_arch = "x86_64", feature = "f16"))]
unsafe impl Immutable for __m512h {}

#[cfg(target_arch = "x86")]
unsafe impl Immutable for __m512i {}

#[cfg(target_arch = "x86_64")]
unsafe impl Immutable for __m512i {}

// SAFETY: `ManuallyDrop<T>` is transparent to `T`.
unsafe impl<T: Immutable> Immutable for ManuallyDrop<T> {}

// SAFETY: `MaybeUninit<T>` is transparent to `T`.
unsafe impl<T: Immutable> Immutable for MaybeUninit<T> {}

// SAFETY: `NonNull<T>` is transparent to
// to `*mut T`.
unsafe impl<T: ?Sized> Immutable for NonNull<T> {}

// SAFETY: `Option<NonZero<i128>>` is transparent
// to `i128`.
unsafe impl Immutable for NonZero<i128> {}

// SAFETY: `Option<NonZero<i16>>` is transparent to
// `i16`.
unsafe impl Immutable for NonZero<i16> {}

// SAFETY: `Option<NonZero<i32>>` is transparent to
// `i32`.
unsafe impl Immutable for NonZero<i32> {}

// SAFETY: `Option<NonZero<i64>>` is transparent to
// `i64`.
unsafe impl Immutable for NonZero<i64> {}

// SAFETY: `Option<NonZero<i8>>` is transparent to
// `i8`.
unsafe impl Immutable for NonZero<i8> {}

// SAFETY: `Option<NonZero<isize>>` is transparent
// to `isize`.
unsafe impl Immutable for NonZero<isize> {}

// SAFETY: `Option<NonZero<u128>>` is transparent
// to `u128`.
unsafe impl Immutable for NonZero<u128> {}

// SAFETY: `Option<NonZero<u16>>` is transparent to
// `u16`.
unsafe impl Immutable for NonZero<u16> {}

// SAFETY: `Option<NonZero<u32>>` is transparent to
// `u32`.
unsafe impl Immutable for NonZero<u32> {}

// SAFETY: `Option<NonZero<u64>>` is transparent to
// `u64`.
unsafe impl Immutable for NonZero<u64> {}

// SAFETY: `Option<NonZero<u8>>` is transparent to
// `u8`.
unsafe impl Immutable for NonZero<u8> {}

// SAFETY: `Option<NonZero<usize>>` is transparent
// to `usize`.
unsafe impl Immutable for NonZero<usize> {}

// SAFETY: The discriminant must be interiour-im-
// mutable as well.
unsafe impl<T: Immutable> Immutable for Option<T> {}

// SORT: pointer
// SAFETY: Pointer metadata must be interiour-im-
// mutable as well.
unsafe impl<T: ?Sized> Immutable for *const T {}

// SORT: pointer
// SAFETY: Pointer metadata must be interiour-im-
// mutable as well.
unsafe impl<T: ?Sized> Immutable for *mut T {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly16x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly16x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly16x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly16x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly16x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly16x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly16x8x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly32x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly32x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly32x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly32x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly32x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly32x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly32x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly32x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly64x1_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly64x1x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly64x1x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly64x1x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly64x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly64x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly64x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly64x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly8x16_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly8x16x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly8x16x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly8x16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly8x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly8x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly8x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for poly8x8x4_t {}

// SORT: reference
// SAFETY: Reference metadata must be interiour-im-
// mutable as well.
unsafe impl<T: ?Sized> Immutable for &T {}

// SORT: reference
// SAFETY: Reference metadata must be interiour-im-
// mutable as well.
unsafe impl<T: ?Sized> Immutable for &mut T {}

// SAFETY: The discriminant must be interiour-im-
// mutable as well.
unsafe impl<T, E> Immutable for Result<T, E>
where
	T: Immutable,
	E: Immutable,
{}

// SORT: tuple
/// Implemented for tuples with up to twelve
/// members.
#[cfg_attr(feature = "unstable_docs", doc(fake_variadic))]
unsafe impl<T: Immutable> Immutable for (T,) {}

// SORT: tuple
#[doc(hidden)]
unsafe impl<T0, T1> Immutable for (T0, T1)
where
	T0: Immutable,
	T1: Immutable,
{}

// SORT: tuple
#[doc(hidden)]
unsafe impl<T0, T1, T2> Immutable for (T0, T1, T2)
where
	T0: Immutable,
	T1: Immutable,
	T2: Immutable,
{}

// SORT: tuple
#[doc(hidden)]
unsafe impl<T0, T1, T2, T3> Immutable for (T0, T1, T2, T3)
where
	T0: Immutable,
	T1: Immutable,
	T2: Immutable,
	T3: Immutable,
{}

// SORT: tuple
#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4> Immutable for (T0, T1, T2, T3, T4)
where
	T0: Immutable,
	T1: Immutable,
	T2: Immutable,
	T3: Immutable,
	T4: Immutable,
{}

// SORT: tuple
#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4, T5> Immutable for (T0, T1, T2, T3, T4, T5)
where
	T0: Immutable,
	T1: Immutable,
	T2: Immutable,
	T3: Immutable,
	T4: Immutable,
	T5: Immutable,
{}

// SORT: tuple
#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Immutable for (T0, T1, T2, T3, T4, T5, T6)
where
	T0: Immutable,
	T1: Immutable,
	T2: Immutable,
	T3: Immutable,
	T4: Immutable,
	T5: Immutable,
	T6: Immutable,
{}

// SORT: tuple
#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Immutable for (T0, T1, T2, T3, T4, T5, T6, T7)
where
	T0: Immutable,
	T1: Immutable,
	T2: Immutable,
	T3: Immutable,
	T4: Immutable,
	T5: Immutable,
	T6: Immutable,
	T7: Immutable,
{}

// SORT: tuple
#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Immutable for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
where
	T0: Immutable,
	T1: Immutable,
	T2: Immutable,
	T3: Immutable,
	T4: Immutable,
	T5: Immutable,
	T6: Immutable,
	T7: Immutable,
	T8: Immutable,
{}

// SORT: tuple
#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Immutable for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
where
	T0: Immutable,
	T1: Immutable,
	T2: Immutable,
	T3: Immutable,
	T4: Immutable,
	T5: Immutable,
	T6: Immutable,
	T7: Immutable,
	T8: Immutable,
	T9: Immutable,
{}

// SORT: tuple
#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Immutable for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
where
	T0:  Immutable,
	T1:  Immutable,
	T2:  Immutable,
	T3:  Immutable,
	T4:  Immutable,
	T5:  Immutable,
	T6:  Immutable,
	T7:  Immutable,
	T8:  Immutable,
	T9:  Immutable,
	T10: Immutable,
{}

// SORT: tuple
#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Immutable for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
where
	T0:  Immutable,
	T1:  Immutable,
	T2:  Immutable,
	T3:  Immutable,
	T4:  Immutable,
	T5:  Immutable,
	T6:  Immutable,
	T7:  Immutable,
	T8:  Immutable,
	T9:  Immutable,
	T10: Immutable,
	T11: Immutable,
{}

unsafe impl Immutable for u128 {}

unsafe impl Immutable for u16 {}

unsafe impl Immutable for u32 {}

unsafe impl Immutable for u64 {}

unsafe impl Immutable for u8 {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint16x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint16x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint16x4x4t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint16x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint16x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint16x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint16x8x4t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint32x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint32x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint32x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint32x2x4t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint32x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint32x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint32x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint32x4x4t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint64x1_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint64x1x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint64x1x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint64x1x4t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint64x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint64x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint64x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint64x2x4t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint8x16_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint8x16x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint8x16x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint8x16x_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint8x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint8x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint8x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Immutable for uint8x8x4_t {}

// SORT: unit
unsafe impl Immutable for () {}

unsafe impl Immutable for usize {}

unsafe impl<T: Immutable> Immutable for Saturating<T> {}

// SORT: slice
unsafe impl<T: Immutable> Immutable for [T] {}

// SAFETY: `str` is tranpsarent to `[u8]`.
unsafe impl Immutable for str {}

unsafe impl<T: Immutable> Immutable for Wrapping<T> {}