oct 0.36.2

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

//! The [`Zeroable`] trait.

mod test;

use core::cell::{Cell, UnsafeCell};
use core::cmp::Reverse;
use core::marker::{PhantomData, PhantomPinned};
use core::mem::{ManuallyDrop, MaybeUninit};
use core::num::{NonZero, Saturating, Wrapping};
use core::ptr::NonNull;

#[cfg(feature = "alloc")]
use alloc::alloc::{alloc_zeroed, handle_alloc_error};

#[cfg(feature = "alloc")]
use alloc::boxed::Box;

#[cfg(feature = "alloc")]
use core::alloc::Layout;

#[cfg(feature = "alloc")]
use oct::Outlay;

#[cfg(feature = "ascii")]
use core::ascii;

#[cfg(feature = "bstr")]
use core::bstr::ByteStr;

#[cfg(feature = "simd")]
use core::simd::{Simd, SimdElement};

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
use core::arch::aarch64 as arch;

#[cfg(target_arch = "wasm32")]
use core::arch::wasm32 as arch;

#[cfg(target_arch = "x86")]
use core::arch::x86 as arch;

#[cfg(target_arch = "x86_64")]
use core::arch::x86_64 as arch;

#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
use core::sync::atomic::{AtomicI128, AtomicU128};

#[cfg(target_has_atomic = "16")]
use core::sync::atomic::{AtomicI16, AtomicU16};

#[cfg(target_has_atomic = "32")]
use core::sync::atomic::{AtomicI32, AtomicU32};

#[cfg(target_has_atomic = "64")]
use core::sync::atomic::{AtomicI64, AtomicU64};

#[cfg(target_has_atomic = "8")]
use core::sync::atomic::{AtomicBool, AtomicI8, AtomicU8};

#[cfg(target_has_atomic = "ptr")]
use core::sync::atomic::{AtomicIsize, AtomicPtr, AtomicUsize};

/// Denotes a type that is zeroable.
///
/// # Safety
///
/// Only types that may be constructed from
/// all-zeros may implement this trait.
///
/// The provided functions of this trait may not be
/// overriden.
#[doc(alias = "FromZeros")]
pub unsafe trait Zeroable {
	/// Constructs a new object from all-zeros.
	///
	/// The returned object is considered initialised
	/// after a successful call to this method.
	///
	/// This function is similar to
	/// [`MaybeUninit::zeroed`] but -- in contrast --
	/// is always safe to use.
	#[inline]
	#[must_use]
	fn new_zeroed() -> Self
	where
		Self: Sized,
	{
		let mut this = MaybeUninit::<Self>::uninit();
		this.make_zeroed();

		// SAFETY: `make_zeroed` guarantees an initialised
		// state. This trait guarantees all-zero isn't an in-
		// variant.
		unsafe { this.assume_init() }
	}

	/// Allocates a zeroed, boxed object.
	///
	/// This function is guaranteed to not
	/// heap-allocate the zeroed object before boxing
	/// it.
	///
	/// # Panics
	///
	/// This constructor will panic if the box could not
	/// be allocated.
	#[cfg(feature = "alloc")]
	#[must_use]
	fn new_zeroed_boxed() -> Box<Self>
	where
		Self: Outlay<Metadata: Default>,
	{
		let metadata = Default::default();
		Self::new_zeroed_boxed_with_metadata(metadata)
	}

	/// Allocates a zeroed, boxed object via metadata.
	///
	/// This function is guaranteed to not
	/// heap-allocate the zeroed object before boxing
	/// it.
	///
	/// # Panics
	///
	/// This constructor will panic if the box could not
	/// be allocated.
	#[cfg(feature = "alloc")]
	#[must_use]
	fn new_zeroed_boxed_with_metadata(metadata: Self::Metadata) -> Box<Self>
	where
		Self: Outlay,
	{
		// Determine the size of the object.

		let Ok(layout) = Self::layout_for_metadata(metadata) else {
			panic!("cannot compute layout for object of size `{metadata:?}`");
		};

		let raw = if layout.size() > 0 {
			// SAFETY:
			// * `size` has been tested to be greater than
			//   zero.
			let data = unsafe { alloc_zeroed(layout) };

			if data.is_null() {
				handle_alloc_error(layout);
			};

			let raw = Self::ptr_from_raw_parts_mut(data, metadata);

			#[cfg(debug_assertions)]
			if layout.size() > 0 {
				// Test that `Box` will get the same layout. This
				// indirectly also tests
				// `Outlay::ptr_from_raw_parts_mut`.

				// SAFETY:
				// * The pointer is properly aligned (as always
				//   guaranteed by the allocator.)
				//
				// * We have already tested that it is non-null.
				//
				// * The address (and range) point within the heap
				//   allocation. Similarly, the provenance is de-
				//   rived from this allocation.
				//
				// * It is exclusive (we have not shared the point-
				//   er) and any read is thus synchronised (and no
				//   write can occur.)
				//
				// * The allocation is not deallocated until long
				//   after the reference goes out of scope.
				//
				// * The destination value is initialised with all-
				//   zeros, and this representation is valid for
				//   `Self` (required by the `Self: Zeroable` bound.)
				let r = unsafe { &*raw };

				debug_assert_eq!(Layout::for_value(r), layout);
			}

			raw
		} else {
			Self::ptr_dangling_with_metadata_mut(metadata)
		};

		debug_assert_eq!(raw.addr() % Self::ALIGN, 0);

		// SAFETY:
		// * The pointer's address is either successfully-
		//   allocated or dangling, but is always non-zero
		//   and aligned.
		//
		// * The destination object, if its type is a non-
		//   ZST, has already been initialised with all-ze-
		//   ros.
		unsafe { Box::from_raw(raw) }
	}

	/// Overwrites the object with all-zeros.
	///
	/// The provided object is considered initialised
	/// after a successful call to this method.
	///
	/// This operation may be desired if the object in
	/// question is a secret and needs to be destroyed.
	#[inline]
	fn make_zeroed(&mut self) {
		let len = size_of_val(self);
		let ptr = (&raw mut *self).cast::<u8>();

		// SAFETY:
		// * `size_of_val` returns the exact size of the
		//   object.
		//
		// * The pointer derives from a reference and can
		//   therefore not be unaligned.
		//
		// * The object is initialised entirely with all-
		//   zeros, and the `Self: Zeroable` bound requires
		//   that this representation is valid.
		unsafe { ptr.write_bytes(0b00000000, len) };
	}
}

// SORT: array
// SAFETY: Arrays do not induce padding.
unsafe impl<T: Zeroable, const N: usize> Zeroable for [T; N] {}

// SAFETY: `AtomicBool` is transparent to `bool`.
#[cfg(target_has_atomic = "8")]
unsafe impl Zeroable for AtomicBool {}

// SAFETY: `AtomicI128` is transparent to `i128`.
#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
unsafe impl Zeroable for AtomicI128 {}

// SAFETY: `AtomicI16` is transparent to `i16`.
#[cfg(target_has_atomic = "16")]
unsafe impl Zeroable for AtomicI16 {}

// SAFETY: `AtomicI32` is transparent to `i32`.
#[cfg(target_has_atomic = "32")]
unsafe impl Zeroable for AtomicI32 {}

// SAFETY: `AtomicI64` is transparent to `i64`.
#[cfg(target_has_atomic = "64")]
unsafe impl Zeroable for AtomicI64 {}

// SAFETY: `AtomicI8` is transparent to `i8`.
#[cfg(target_has_atomic = "8")]
unsafe impl Zeroable for AtomicI8 {}

// SAFETY: `AtomicUsize` is transparent to `usize`.
#[cfg(target_has_atomic = "ptr")]
unsafe impl Zeroable for AtomicIsize {}

// FIXME: Require `T: Thin` instead of `T: Sized`.
// SAFETY: `AtomicPtr<T>` is transparent to
// `usize` when `T: Sized`.
#[cfg(target_has_atomic = "ptr")]
unsafe impl<T> Zeroable for AtomicPtr<T> {}

// SAFETY: `AtomicU128` is transparent to `u128`.
#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
unsafe impl Zeroable for AtomicU128 {}

// SAFETY: `AtomicU16` is transparent to `u16`.
#[cfg(target_has_atomic = "16")]
unsafe impl Zeroable for AtomicU16 {}

// SAFETY: `AtomicU32` is transparent to `u32`.
#[cfg(target_has_atomic = "32")]
unsafe impl Zeroable for AtomicU32 {}

// SAFETY: `AtomicU64` is transparent to `u64`.
#[cfg(target_has_atomic = "64")]
unsafe impl Zeroable for AtomicU64 {}

// SAFETY: `AtomicU8` is transparent to `u8`.
#[cfg(target_has_atomic = "8")]
unsafe impl Zeroable for AtomicU8 {}

// SAFETY: `AtomicUsize` is transparent to `usize`.
#[cfg(target_has_atomic = "ptr")]
unsafe impl Zeroable for AtomicUsize {}

// SAFETY: All-zeros corresponds to `false`.
unsafe impl Zeroable for bool {}

// SAFETY: `ByteStr` is transparent to `[u8]`.
#[cfg(feature = "bstr")]
unsafe impl Zeroable for ByteStr {}

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

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

// SAFETY: All-zeros corresponds to `Null`.
#[cfg(feature = "ascii")]
unsafe impl Zeroable for ascii::Char {}

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

// SAFETY: This structure is exhaustive and homoge-
// neous.
#[cfg(feature = "f128")]
unsafe impl Zeroable for f128 {}

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

unsafe impl Zeroable for f32 {}

unsafe impl Zeroable for f64 {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Zeroable for arch::float16x4_t {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Zeroable for arch::float16x4x2_t {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Zeroable for arch::float16x4x3_t {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Zeroable for arch::float16x4x4_t {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Zeroable for arch::float16x8_t {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Zeroable for arch::float16x8x2_t {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Zeroable for arch::float16x8x3_t {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Zeroable for arch::float16x8x4_t {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

unsafe impl Zeroable for i128 {}

unsafe impl Zeroable for i16 {}

unsafe impl Zeroable for i32 {}

unsafe impl Zeroable for i64 {}

unsafe impl Zeroable for i8 {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

unsafe impl Zeroable for isize {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Zeroable for arch::__m128 {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
unsafe impl Zeroable for arch::__m128bh {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Zeroable for arch::__m128d {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
unsafe impl Zeroable for arch::__m128h {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Zeroable for arch::__m128i {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Zeroable for arch::__m256 {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
unsafe impl Zeroable for arch::__m256bh {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Zeroable for arch::__m256d {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
unsafe impl Zeroable for arch::__m256h {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Zeroable for arch::__m256i {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Zeroable for arch::__m512 {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
unsafe impl Zeroable for arch::__m512bh {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Zeroable for arch::__m512d {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
unsafe impl Zeroable for arch::__m512h {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Zeroable for arch::__m512i {}

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

// SAFETY: `MaybeUninit<T>` supports any represen-
// tation.
unsafe impl<T> Zeroable for MaybeUninit<T> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl Zeroable for Option<fn()> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T> Zeroable for Option<fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1> Zeroable for Option<fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2> Zeroable for Option<fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3> Zeroable for Option<fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl Zeroable for Option<extern "aapcs" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T> Zeroable for Option<extern "aapcs" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1> Zeroable for Option<extern "aapcs" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2> Zeroable for Option<extern "aapcs" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "aapcs" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "aapcs" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "aapcs" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl Zeroable for Option<extern "aapcs-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T> Zeroable for Option<extern "aapcs-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1> Zeroable for Option<extern "aapcs-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2> Zeroable for Option<extern "aapcs-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "aapcs-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "aapcs-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl Zeroable for Option<extern "C" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T> Zeroable for Option<extern "C" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1> Zeroable for Option<extern "C" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2> Zeroable for Option<extern "C" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "C" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "C" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "C" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "C" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl Zeroable for Option<extern "C-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T> Zeroable for Option<extern "C-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1> Zeroable for Option<extern "C-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2> Zeroable for Option<extern "C-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "C-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "C-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "C-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<extern "cdecl" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<extern "cdecl" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<extern "cdecl" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<extern "cdecl" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "cdecl" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "cdecl" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "cdecl" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<extern "cdecl-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<extern "cdecl-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<extern "cdecl-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<extern "cdecl-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "cdecl-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "cdecl-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Zeroable for Option<extern "efiapi" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T> Zeroable for Option<extern "efiapi" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1> Zeroable for Option<extern "efiapi" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2> Zeroable for Option<extern "efiapi" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "efiapi" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "efiapi" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "efiapi" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[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> Zeroable for Option<extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[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> Zeroable for Option<extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[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> Zeroable for Option<extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[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> Zeroable for Option<extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[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> Zeroable for Option<extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<extern "fastcall" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<extern "fastcall" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<extern "fastcall" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<extern "fastcall" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "fastcall" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "fastcall" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "fastcall" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<extern "fastcall-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<extern "fastcall-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<extern "fastcall-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<extern "fastcall-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "fastcall-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "fastcall-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<extern "stdcall" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<extern "stdcall" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<extern "stdcall" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<extern "stdcall" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "stdcall" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "stdcall" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "stdcall" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<extern "stdcall-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<extern "stdcall-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<extern "stdcall-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<extern "stdcall-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "stdcall-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "stdcall-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl Zeroable for Option<extern "sysv64" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T> Zeroable for Option<extern "sysv64" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1> Zeroable for Option<extern "sysv64" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2> Zeroable for Option<extern "sysv64" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "sysv64" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "sysv64" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "sysv64" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl Zeroable for Option<extern "sysv64-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T> Zeroable for Option<extern "sysv64-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1> Zeroable for Option<extern "sysv64-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2> Zeroable for Option<extern "sysv64-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "sysv64-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "sysv64-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl Zeroable for Option<extern "system" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T> Zeroable for Option<extern "system" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1> Zeroable for Option<extern "system" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2> Zeroable for Option<extern "system" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "system" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "system" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "system" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "system" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl Zeroable for Option<extern "system-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T> Zeroable for Option<extern "system-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1> Zeroable for Option<extern "system-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2> Zeroable for Option<extern "system-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "system-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "system-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "system-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<extern "thiscall" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<extern "thiscall" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<extern "thiscall" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<extern "thiscall" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "thiscall" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "thiscall" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "thiscall" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<extern "thiscall-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<extern "thiscall-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<extern "thiscall-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<extern "thiscall-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "thiscall-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "thiscall-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl Zeroable for Option<extern "win64" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T> Zeroable for Option<extern "win64" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1> Zeroable for Option<extern "win64" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2> Zeroable for Option<extern "win64" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "win64" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "win64" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "win64" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "win64" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl Zeroable for Option<extern "win64-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T> Zeroable for Option<extern "win64-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1> Zeroable for Option<extern "win64-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2> Zeroable for Option<extern "win64-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<extern "win64-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<extern "win64-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl Zeroable for Option<unsafe fn()> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T> Zeroable for Option<unsafe fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1> Zeroable for Option<unsafe fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl Zeroable for Option<unsafe extern "aapcs" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T> Zeroable for Option<unsafe extern "aapcs" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "aapcs" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "aapcs" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "aapcs" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "aapcs" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "aapcs" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "aapcs" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl Zeroable for Option<unsafe extern "aapcs-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T> Zeroable for Option<unsafe extern "aapcs-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "aapcs-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "aapcs-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "arm")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "aapcs-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl Zeroable for Option<unsafe extern "C" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T> Zeroable for Option<unsafe extern "C" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "C" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "C" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "C" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "C" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "C" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "C" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "C" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl Zeroable for Option<unsafe extern "C-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T> Zeroable for Option<unsafe extern "C-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "C-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "C-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "C-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "C-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<unsafe extern "cdecl" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<unsafe extern "cdecl" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "cdecl" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "cdecl" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "cdecl" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "cdecl" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "cdecl" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "cdecl" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<unsafe extern "cdecl-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<unsafe extern "cdecl-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "cdecl-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "cdecl-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "cdecl-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Zeroable for Option<unsafe extern "efiapi" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T> Zeroable for Option<unsafe extern "efiapi" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "efiapi" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "efiapi" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "efiapi" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "efiapi" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "efiapi" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[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> Zeroable for Option<unsafe extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[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> Zeroable for Option<unsafe extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[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> Zeroable for Option<unsafe extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[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> Zeroable for Option<unsafe extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[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> Zeroable for Option<unsafe extern "efiapi" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<unsafe extern "fastcall" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<unsafe extern "fastcall" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "fastcall" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "fastcall" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "fastcall" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "fastcall" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "fastcall" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "fastcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<unsafe extern "fastcall-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<unsafe extern "fastcall-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "fastcall-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "fastcall-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "fastcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<unsafe extern "stdcall" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<unsafe extern "stdcall" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "stdcall" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "stdcall" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "stdcall" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "stdcall" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "stdcall" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "stdcall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<unsafe extern "stdcall-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<unsafe extern "stdcall-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "stdcall-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "stdcall-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "stdcall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl Zeroable for Option<unsafe extern "sysv64" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T> Zeroable for Option<unsafe extern "sysv64" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "sysv64" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "sysv64" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "sysv64" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "sysv64" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "sysv64" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "sysv64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl Zeroable for Option<unsafe extern "sysv64-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T> Zeroable for Option<unsafe extern "sysv64-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "sysv64-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "sysv64-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "sysv64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl Zeroable for Option<unsafe extern "system" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T> Zeroable for Option<unsafe extern "system" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "system" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "system" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "system" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "system" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "system" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "system" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "system" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl Zeroable for Option<unsafe extern "system-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T> Zeroable for Option<unsafe extern "system-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "system-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "system-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "system-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "system-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<unsafe extern "thiscall" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<unsafe extern "thiscall" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "thiscall" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "thiscall" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "thiscall" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "thiscall" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "thiscall" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "thiscall" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl Zeroable for Option<unsafe extern "thiscall-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T> Zeroable for Option<unsafe extern "thiscall-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "thiscall-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "thiscall-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "thiscall-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl Zeroable for Option<unsafe extern "win64" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T> Zeroable for Option<unsafe extern "win64" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "win64" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "win64" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "win64" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "win64" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "win64" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "win64" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "win64" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl Zeroable for Option<unsafe extern "win64-unwind" fn()> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T> Zeroable for Option<unsafe extern "win64-unwind" fn(T)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1> Zeroable for Option<unsafe extern "win64-unwind" fn(T0, T1)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2> Zeroable for Option<unsafe extern "win64-unwind" fn(T0, T1, T2)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3> Zeroable for Option<unsafe extern "win64-unwind" fn(T0, T1, T2, T3)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4> Zeroable for Option<unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5> Zeroable for Option<unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> Zeroable for Option<unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> Zeroable for Option<unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Zeroable for Option<unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Zeroable for Option<unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Zeroable for Option<unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {}

// SAFETY: All-zeros corresponds to `None`.
#[cfg(target_arch = "x86_64")]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Zeroable for Option<unsafe extern "win64-unwind" fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> {}

// FIXME: Require `T: Thin` instead of `T: Sized`.
// SAFETY: `Option<NonNull<T>>` is transparent to
// to `Option<NonZero<usize>>` when `T: Sized`.
unsafe impl<T> Zeroable for Option<NonNull<T>> {}

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

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

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

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

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

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

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

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

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

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

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

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

// SAFETY: `PhantomData<T>` is a ZST but still in-
// habited.
unsafe impl<T: ?Sized> Zeroable for PhantomData<T> {}

// SAFETY: `PhantomPinned` is a ZST but still in-
// habited.
unsafe impl Zeroable for PhantomPinned {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SORT: pointer
// FIXME: Require `T: Thin` instead of `T: Sized`.
// SAFETY: `*const T` is transparent to `usize`.
unsafe impl<T> Zeroable for *const T {}

// SORT: pointer
// FIXME: Require `T: Thin` instead of `T: Sized`.
// SAFETY: `*mut T` is transparent to `usize`.
unsafe impl<T> Zeroable for *mut T {}

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

#[cfg(feature = "simd")]
unsafe impl<T: SimdElement + Zeroable, const N: usize> Zeroable for Simd<T, N> {}

// SORT: slice
// SAFETY: Slices have the same representation as
// arrays.
unsafe impl<T: Zeroable> Zeroable for [T] {}

// SAFETY: Each zero corresponds to a UTF-8-encoded
// `\0`.
unsafe impl Zeroable for str {}

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

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

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

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

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

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

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

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

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

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

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

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

unsafe impl Zeroable for u128 {}

unsafe impl Zeroable for u16 {}

unsafe impl Zeroable for u32 {}

unsafe impl Zeroable for u64 {}

unsafe impl Zeroable for u8 {}

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

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

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

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Zeroable for arch::uint16x4x4_t {}

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

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

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

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Zeroable for arch::uint16x8x4_t {}

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

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

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

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Zeroable for arch::uint32x2x4_t {}

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

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

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

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Zeroable for arch::uint32x4x4_t {}

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

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

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

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Zeroable for arch::uint64x1x4_t {}

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

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

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

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Zeroable for arch::uint64x2x4_t {}

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

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

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

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Zeroable for arch::uint8x16x4_t {}

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

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

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

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

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

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

unsafe impl Zeroable for usize {}

#[cfg(target_arch = "wasm32")]
unsafe impl Zeroable for arch::v128 {}

// SAFETY: `Wrappings<T>` is transparent to `T`.
unsafe impl<T: Zeroable> Zeroable for Wrapping<T> {}