html-to-markdown 2.23.4 → 2.24.1

data/rust-vendor/zerocopy-derive/src/output_tests/expected/try_from_bytes_enum_2.expected.rs

@@ -0,0 +1,2802 @@
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl<'a: 'static, X, Y: Deref, const N: usize> ::zerocopy::TryFromBytes
+    for ComplexWithGenerics<'a, { N }, X, Y>
+    where
+        X: Deref<Target = &'a [(X, Y); N]>,
+        u8: ::zerocopy::TryFromBytes,
+        X: ::zerocopy::TryFromBytes,
+        X::Target: ::zerocopy::TryFromBytes,
+        Y::Target: ::zerocopy::TryFromBytes,
+        [(X, Y); N]: ::zerocopy::TryFromBytes,
+        bool: ::zerocopy::TryFromBytes,
+        Y: ::zerocopy::TryFromBytes,
+        PhantomData<&'a [(X, Y); N]>: ::zerocopy::TryFromBytes,
+    {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+        fn is_bit_valid(
+            mut candidate: ::zerocopy::Maybe<'_, Self>,
+        ) -> ::zerocopy::util::macro_util::core_reexport::primitive::bool {
+            #[repr(u32)]
+            #[allow(dead_code)]
+            pub enum ___ZerocopyTag {
+                UnitLike,
+                StructLike,
+                TupleLike,
+            }
+            unsafe impl ::zerocopy::Immutable for ___ZerocopyTag {
+                fn only_derive_is_allowed_to_implement_this_trait() {}
+            }
+            type ___ZerocopyTagPrimitive = ::zerocopy::util::macro_util::SizeToTag<
+                {
+                    ::zerocopy::util::macro_util::core_reexport::mem::size_of::<
+                        ___ZerocopyTag,
+                    >()
+                },
+            >;
+            const ___ZEROCOPY_TAG_UnitLike: ___ZerocopyTagPrimitive = ___ZerocopyTag::UnitLike
+                as ___ZerocopyTagPrimitive;
+            const ___ZEROCOPY_TAG_StructLike: ___ZerocopyTagPrimitive = ___ZerocopyTag::StructLike
+                as ___ZerocopyTagPrimitive;
+            const ___ZEROCOPY_TAG_TupleLike: ___ZerocopyTagPrimitive = ___ZerocopyTag::TupleLike
+                as ___ZerocopyTagPrimitive;
+            type ___ZerocopyOuterTag = ();
+            type ___ZerocopyInnerTag = ___ZerocopyTag;
+            #[repr(C)]
+            struct ___ZerocopyVariantStruct_StructLike<
+                'a: 'static,
+                const N: usize,
+                X,
+                Y: Deref,
+            >(
+                ::zerocopy::util::macro_util::core_reexport::mem::MaybeUninit<
+                    ___ZerocopyInnerTag,
+                >,
+                u8,
+                X,
+                X::Target,
+                Y::Target,
+                [(X, Y); N],
+                ::zerocopy::util::macro_util::core_reexport::marker::PhantomData<
+                    ComplexWithGenerics<'a, N, X, Y>,
+                >,
+            )
+            where
+                X: Deref<Target = &'a [(X, Y); N]>;
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    const N: usize,
+                > ::zerocopy::TryFromBytes
+                for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                    ::zerocopy::util::macro_util::core_reexport::mem::MaybeUninit<
+                        ___ZerocopyInnerTag,
+                    >: ::zerocopy::TryFromBytes,
+                    u8: ::zerocopy::TryFromBytes,
+                    X: ::zerocopy::TryFromBytes,
+                    X::Target: ::zerocopy::TryFromBytes,
+                    Y::Target: ::zerocopy::TryFromBytes,
+                    [(X, Y); N]: ::zerocopy::TryFromBytes,
+                    ::zerocopy::util::macro_util::core_reexport::marker::PhantomData<
+                        ComplexWithGenerics<'a, N, X, Y>,
+                    >: ::zerocopy::TryFromBytes,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    fn is_bit_valid(
+                        mut candidate: ::zerocopy::Maybe<Self>,
+                    ) -> ::zerocopy::util::macro_util::core_reexport::primitive::bool {
+                        true
+                            && {
+                                let field_candidate = ::zerocopy::into_inner!(
+                                    candidate.reborrow().project:: < _, {
+                                    ::zerocopy::STRUCT_VARIANT_ID }, { ::zerocopy::ident_id!(0)
+                                    } > ()
+                                );
+                                <::zerocopy::util::macro_util::core_reexport::mem::MaybeUninit<
+                                    ___ZerocopyInnerTag,
+                                > as ::zerocopy::TryFromBytes>::is_bit_valid(
+                                    field_candidate,
+                                )
+                            }
+                            && {
+                                let field_candidate = ::zerocopy::into_inner!(
+                                    candidate.reborrow().project:: < _, {
+                                    ::zerocopy::STRUCT_VARIANT_ID }, { ::zerocopy::ident_id!(1)
+                                    } > ()
+                                );
+                                <u8 as ::zerocopy::TryFromBytes>::is_bit_valid(
+                                    field_candidate,
+                                )
+                            }
+                            && {
+                                let field_candidate = ::zerocopy::into_inner!(
+                                    candidate.reborrow().project:: < _, {
+                                    ::zerocopy::STRUCT_VARIANT_ID }, { ::zerocopy::ident_id!(2)
+                                    } > ()
+                                );
+                                <X as ::zerocopy::TryFromBytes>::is_bit_valid(
+                                    field_candidate,
+                                )
+                            }
+                            && {
+                                let field_candidate = ::zerocopy::into_inner!(
+                                    candidate.reborrow().project:: < _, {
+                                    ::zerocopy::STRUCT_VARIANT_ID }, { ::zerocopy::ident_id!(3)
+                                    } > ()
+                                );
+                                <X::Target as ::zerocopy::TryFromBytes>::is_bit_valid(
+                                    field_candidate,
+                                )
+                            }
+                            && {
+                                let field_candidate = ::zerocopy::into_inner!(
+                                    candidate.reborrow().project:: < _, {
+                                    ::zerocopy::STRUCT_VARIANT_ID }, { ::zerocopy::ident_id!(4)
+                                    } > ()
+                                );
+                                <Y::Target as ::zerocopy::TryFromBytes>::is_bit_valid(
+                                    field_candidate,
+                                )
+                            }
+                            && {
+                                let field_candidate = ::zerocopy::into_inner!(
+                                    candidate.reborrow().project:: < _, {
+                                    ::zerocopy::STRUCT_VARIANT_ID }, { ::zerocopy::ident_id!(5)
+                                    } > ()
+                                );
+                                <[(
+                                    X,
+                                    Y,
+                                ); N] as ::zerocopy::TryFromBytes>::is_bit_valid(
+                                    field_candidate,
+                                )
+                            }
+                            && {
+                                let field_candidate = ::zerocopy::into_inner!(
+                                    candidate.reborrow().project:: < _, {
+                                    ::zerocopy::STRUCT_VARIANT_ID }, { ::zerocopy::ident_id!(6)
+                                    } > ()
+                                );
+                                <::zerocopy::util::macro_util::core_reexport::marker::PhantomData<
+                                    ComplexWithGenerics<'a, N, X, Y>,
+                                > as ::zerocopy::TryFromBytes>::is_bit_valid(
+                                    field_candidate,
+                                )
+                            }
+                    }
+                }
+                #[allow(
+                    deprecated,
+                    private_bounds,
+                    non_local_definitions,
+                    non_camel_case_types,
+                    non_upper_case_globals,
+                    non_snake_case,
+                    non_ascii_idents,
+                    clippy::missing_inline_in_public_items,
+                )]
+                #[deny(ambiguous_associated_items)]
+                #[automatically_derived]
+                const _: () = {
+                    enum ẕ0 {}
+                    enum ẕ1 {}
+                    enum ẕ2 {}
+                    enum ẕ3 {}
+                    enum ẕ4 {}
+                    enum ẕ5 {}
+                    enum ẕ6 {}
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            const N: usize,
+                        > ::zerocopy::HasTag
+                        for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                        where
+                            X: Deref<Target = &'a [(X, Y); N]>,
+                        {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Tag = ();
+                            type ProjectToTag = ::zerocopy::pointer::cast::CastToUnit;
+                        }
+                    };
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            const N: usize,
+                        > ::zerocopy::HasField<
+                            ẕ0,
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(0) },
+                        > for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                        where
+                            X: Deref<Target = &'a [(X, Y); N]>,
+                        {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Type = ::zerocopy::util::macro_util::core_reexport::mem::MaybeUninit<
+                                ___ZerocopyInnerTag,
+                            >;
+                            #[inline(always)]
+                            fn project(
+                                slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                            ) -> *mut <Self as ::zerocopy::HasField<
+                                ẕ0,
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(0) },
+                            >>::Type {
+                                let slf = slf.as_ptr();
+                                unsafe {
+                                    ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                        (* slf).0
+                                    )
+                                }
+                            }
+                        }
+                        #[allow(
+                            deprecated,
+                            private_bounds,
+                            non_local_definitions,
+                            non_camel_case_types,
+                            non_upper_case_globals,
+                            non_snake_case,
+                            non_ascii_idents,
+                            clippy::missing_inline_in_public_items,
+                        )]
+                        #[deny(ambiguous_associated_items)]
+                        #[automatically_derived]
+                        const _: () = {
+                            unsafe impl<
+                                'a: 'static,
+                                X,
+                                Y: Deref,
+                                Aliasing: ::zerocopy::invariant::Aliasing,
+                                Alignment: ::zerocopy::invariant::Alignment,
+                                const N: usize,
+                            > ::zerocopy::ProjectField<
+                                ẕ0,
+                                (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(0) },
+                            > for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                            where
+                                X: Deref<Target = &'a [(X, Y); N]>,
+                            {
+                                fn only_derive_is_allowed_to_implement_this_trait() {}
+                                type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                                type Invariants = (
+                                    Aliasing,
+                                    Alignment,
+                                    ::zerocopy::invariant::Initialized,
+                                );
+                            }
+                        };
+                    };
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            const N: usize,
+                        > ::zerocopy::HasField<
+                            ẕ1,
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(1) },
+                        > for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                        where
+                            X: Deref<Target = &'a [(X, Y); N]>,
+                        {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Type = u8;
+                            #[inline(always)]
+                            fn project(
+                                slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                            ) -> *mut <Self as ::zerocopy::HasField<
+                                ẕ1,
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(1) },
+                            >>::Type {
+                                let slf = slf.as_ptr();
+                                unsafe {
+                                    ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                        (* slf).1
+                                    )
+                                }
+                            }
+                        }
+                        #[allow(
+                            deprecated,
+                            private_bounds,
+                            non_local_definitions,
+                            non_camel_case_types,
+                            non_upper_case_globals,
+                            non_snake_case,
+                            non_ascii_idents,
+                            clippy::missing_inline_in_public_items,
+                        )]
+                        #[deny(ambiguous_associated_items)]
+                        #[automatically_derived]
+                        const _: () = {
+                            unsafe impl<
+                                'a: 'static,
+                                X,
+                                Y: Deref,
+                                Aliasing: ::zerocopy::invariant::Aliasing,
+                                Alignment: ::zerocopy::invariant::Alignment,
+                                const N: usize,
+                            > ::zerocopy::ProjectField<
+                                ẕ1,
+                                (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(1) },
+                            > for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                            where
+                                X: Deref<Target = &'a [(X, Y); N]>,
+                            {
+                                fn only_derive_is_allowed_to_implement_this_trait() {}
+                                type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                                type Invariants = (
+                                    Aliasing,
+                                    Alignment,
+                                    ::zerocopy::invariant::Initialized,
+                                );
+                            }
+                        };
+                    };
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            const N: usize,
+                        > ::zerocopy::HasField<
+                            ẕ2,
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(2) },
+                        > for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                        where
+                            X: Deref<Target = &'a [(X, Y); N]>,
+                        {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Type = X;
+                            #[inline(always)]
+                            fn project(
+                                slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                            ) -> *mut <Self as ::zerocopy::HasField<
+                                ẕ2,
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(2) },
+                            >>::Type {
+                                let slf = slf.as_ptr();
+                                unsafe {
+                                    ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                        (* slf).2
+                                    )
+                                }
+                            }
+                        }
+                        #[allow(
+                            deprecated,
+                            private_bounds,
+                            non_local_definitions,
+                            non_camel_case_types,
+                            non_upper_case_globals,
+                            non_snake_case,
+                            non_ascii_idents,
+                            clippy::missing_inline_in_public_items,
+                        )]
+                        #[deny(ambiguous_associated_items)]
+                        #[automatically_derived]
+                        const _: () = {
+                            unsafe impl<
+                                'a: 'static,
+                                X,
+                                Y: Deref,
+                                Aliasing: ::zerocopy::invariant::Aliasing,
+                                Alignment: ::zerocopy::invariant::Alignment,
+                                const N: usize,
+                            > ::zerocopy::ProjectField<
+                                ẕ2,
+                                (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(2) },
+                            > for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                            where
+                                X: Deref<Target = &'a [(X, Y); N]>,
+                            {
+                                fn only_derive_is_allowed_to_implement_this_trait() {}
+                                type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                                type Invariants = (
+                                    Aliasing,
+                                    Alignment,
+                                    ::zerocopy::invariant::Initialized,
+                                );
+                            }
+                        };
+                    };
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            const N: usize,
+                        > ::zerocopy::HasField<
+                            ẕ3,
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(3) },
+                        > for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                        where
+                            X: Deref<Target = &'a [(X, Y); N]>,
+                        {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Type = X::Target;
+                            #[inline(always)]
+                            fn project(
+                                slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                            ) -> *mut <Self as ::zerocopy::HasField<
+                                ẕ3,
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(3) },
+                            >>::Type {
+                                let slf = slf.as_ptr();
+                                unsafe {
+                                    ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                        (* slf).3
+                                    )
+                                }
+                            }
+                        }
+                        #[allow(
+                            deprecated,
+                            private_bounds,
+                            non_local_definitions,
+                            non_camel_case_types,
+                            non_upper_case_globals,
+                            non_snake_case,
+                            non_ascii_idents,
+                            clippy::missing_inline_in_public_items,
+                        )]
+                        #[deny(ambiguous_associated_items)]
+                        #[automatically_derived]
+                        const _: () = {
+                            unsafe impl<
+                                'a: 'static,
+                                X,
+                                Y: Deref,
+                                Aliasing: ::zerocopy::invariant::Aliasing,
+                                Alignment: ::zerocopy::invariant::Alignment,
+                                const N: usize,
+                            > ::zerocopy::ProjectField<
+                                ẕ3,
+                                (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(3) },
+                            > for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                            where
+                                X: Deref<Target = &'a [(X, Y); N]>,
+                            {
+                                fn only_derive_is_allowed_to_implement_this_trait() {}
+                                type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                                type Invariants = (
+                                    Aliasing,
+                                    Alignment,
+                                    ::zerocopy::invariant::Initialized,
+                                );
+                            }
+                        };
+                    };
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            const N: usize,
+                        > ::zerocopy::HasField<
+                            ẕ4,
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(4) },
+                        > for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                        where
+                            X: Deref<Target = &'a [(X, Y); N]>,
+                        {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Type = Y::Target;
+                            #[inline(always)]
+                            fn project(
+                                slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                            ) -> *mut <Self as ::zerocopy::HasField<
+                                ẕ4,
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(4) },
+                            >>::Type {
+                                let slf = slf.as_ptr();
+                                unsafe {
+                                    ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                        (* slf).4
+                                    )
+                                }
+                            }
+                        }
+                        #[allow(
+                            deprecated,
+                            private_bounds,
+                            non_local_definitions,
+                            non_camel_case_types,
+                            non_upper_case_globals,
+                            non_snake_case,
+                            non_ascii_idents,
+                            clippy::missing_inline_in_public_items,
+                        )]
+                        #[deny(ambiguous_associated_items)]
+                        #[automatically_derived]
+                        const _: () = {
+                            unsafe impl<
+                                'a: 'static,
+                                X,
+                                Y: Deref,
+                                Aliasing: ::zerocopy::invariant::Aliasing,
+                                Alignment: ::zerocopy::invariant::Alignment,
+                                const N: usize,
+                            > ::zerocopy::ProjectField<
+                                ẕ4,
+                                (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(4) },
+                            > for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                            where
+                                X: Deref<Target = &'a [(X, Y); N]>,
+                            {
+                                fn only_derive_is_allowed_to_implement_this_trait() {}
+                                type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                                type Invariants = (
+                                    Aliasing,
+                                    Alignment,
+                                    ::zerocopy::invariant::Initialized,
+                                );
+                            }
+                        };
+                    };
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            const N: usize,
+                        > ::zerocopy::HasField<
+                            ẕ5,
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(5) },
+                        > for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                        where
+                            X: Deref<Target = &'a [(X, Y); N]>,
+                        {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Type = [(X, Y); N];
+                            #[inline(always)]
+                            fn project(
+                                slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                            ) -> *mut <Self as ::zerocopy::HasField<
+                                ẕ5,
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(5) },
+                            >>::Type {
+                                let slf = slf.as_ptr();
+                                unsafe {
+                                    ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                        (* slf).5
+                                    )
+                                }
+                            }
+                        }
+                        #[allow(
+                            deprecated,
+                            private_bounds,
+                            non_local_definitions,
+                            non_camel_case_types,
+                            non_upper_case_globals,
+                            non_snake_case,
+                            non_ascii_idents,
+                            clippy::missing_inline_in_public_items,
+                        )]
+                        #[deny(ambiguous_associated_items)]
+                        #[automatically_derived]
+                        const _: () = {
+                            unsafe impl<
+                                'a: 'static,
+                                X,
+                                Y: Deref,
+                                Aliasing: ::zerocopy::invariant::Aliasing,
+                                Alignment: ::zerocopy::invariant::Alignment,
+                                const N: usize,
+                            > ::zerocopy::ProjectField<
+                                ẕ5,
+                                (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(5) },
+                            > for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                            where
+                                X: Deref<Target = &'a [(X, Y); N]>,
+                            {
+                                fn only_derive_is_allowed_to_implement_this_trait() {}
+                                type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                                type Invariants = (
+                                    Aliasing,
+                                    Alignment,
+                                    ::zerocopy::invariant::Initialized,
+                                );
+                            }
+                        };
+                    };
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            const N: usize,
+                        > ::zerocopy::HasField<
+                            ẕ6,
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(6) },
+                        > for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                        where
+                            X: Deref<Target = &'a [(X, Y); N]>,
+                        {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Type = ::zerocopy::util::macro_util::core_reexport::marker::PhantomData<
+                                ComplexWithGenerics<'a, N, X, Y>,
+                            >;
+                            #[inline(always)]
+                            fn project(
+                                slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                            ) -> *mut <Self as ::zerocopy::HasField<
+                                ẕ6,
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(6) },
+                            >>::Type {
+                                let slf = slf.as_ptr();
+                                unsafe {
+                                    ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                        (* slf).6
+                                    )
+                                }
+                            }
+                        }
+                        #[allow(
+                            deprecated,
+                            private_bounds,
+                            non_local_definitions,
+                            non_camel_case_types,
+                            non_upper_case_globals,
+                            non_snake_case,
+                            non_ascii_idents,
+                            clippy::missing_inline_in_public_items,
+                        )]
+                        #[deny(ambiguous_associated_items)]
+                        #[automatically_derived]
+                        const _: () = {
+                            unsafe impl<
+                                'a: 'static,
+                                X,
+                                Y: Deref,
+                                Aliasing: ::zerocopy::invariant::Aliasing,
+                                Alignment: ::zerocopy::invariant::Alignment,
+                                const N: usize,
+                            > ::zerocopy::ProjectField<
+                                ẕ6,
+                                (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(6) },
+                            > for ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y>
+                            where
+                                X: Deref<Target = &'a [(X, Y); N]>,
+                            {
+                                fn only_derive_is_allowed_to_implement_this_trait() {}
+                                type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                                type Invariants = (
+                                    Aliasing,
+                                    Alignment,
+                                    ::zerocopy::invariant::Initialized,
+                                );
+                            }
+                        };
+                    };
+                };
+            };
+            #[repr(C)]
+            struct ___ZerocopyVariantStruct_TupleLike<
+                'a: 'static,
+                const N: usize,
+                X,
+                Y: Deref,
+            >(
+                ::zerocopy::util::macro_util::core_reexport::mem::MaybeUninit<
+                    ___ZerocopyInnerTag,
+                >,
+                bool,
+                Y,
+                PhantomData<&'a [(X, Y); N]>,
+                ::zerocopy::util::macro_util::core_reexport::marker::PhantomData<
+                    ComplexWithGenerics<'a, N, X, Y>,
+                >,
+            )
+            where
+                X: Deref<Target = &'a [(X, Y); N]>;
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    const N: usize,
+                > ::zerocopy::TryFromBytes
+                for ___ZerocopyVariantStruct_TupleLike<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                    ::zerocopy::util::macro_util::core_reexport::mem::MaybeUninit<
+                        ___ZerocopyInnerTag,
+                    >: ::zerocopy::TryFromBytes,
+                    bool: ::zerocopy::TryFromBytes,
+                    Y: ::zerocopy::TryFromBytes,
+                    PhantomData<&'a [(X, Y); N]>: ::zerocopy::TryFromBytes,
+                    ::zerocopy::util::macro_util::core_reexport::marker::PhantomData<
+                        ComplexWithGenerics<'a, N, X, Y>,
+                    >: ::zerocopy::TryFromBytes,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    fn is_bit_valid(
+                        mut candidate: ::zerocopy::Maybe<Self>,
+                    ) -> ::zerocopy::util::macro_util::core_reexport::primitive::bool {
+                        true
+                            && {
+                                let field_candidate = ::zerocopy::into_inner!(
+                                    candidate.reborrow().project:: < _, {
+                                    ::zerocopy::STRUCT_VARIANT_ID }, { ::zerocopy::ident_id!(0)
+                                    } > ()
+                                );
+                                <::zerocopy::util::macro_util::core_reexport::mem::MaybeUninit<
+                                    ___ZerocopyInnerTag,
+                                > as ::zerocopy::TryFromBytes>::is_bit_valid(
+                                    field_candidate,
+                                )
+                            }
+                            && {
+                                let field_candidate = ::zerocopy::into_inner!(
+                                    candidate.reborrow().project:: < _, {
+                                    ::zerocopy::STRUCT_VARIANT_ID }, { ::zerocopy::ident_id!(1)
+                                    } > ()
+                                );
+                                <bool as ::zerocopy::TryFromBytes>::is_bit_valid(
+                                    field_candidate,
+                                )
+                            }
+                            && {
+                                let field_candidate = ::zerocopy::into_inner!(
+                                    candidate.reborrow().project:: < _, {
+                                    ::zerocopy::STRUCT_VARIANT_ID }, { ::zerocopy::ident_id!(2)
+                                    } > ()
+                                );
+                                <Y as ::zerocopy::TryFromBytes>::is_bit_valid(
+                                    field_candidate,
+                                )
+                            }
+                            && {
+                                let field_candidate = ::zerocopy::into_inner!(
+                                    candidate.reborrow().project:: < _, {
+                                    ::zerocopy::STRUCT_VARIANT_ID }, { ::zerocopy::ident_id!(3)
+                                    } > ()
+                                );
+                                <PhantomData<
+                                    &'a [(X, Y); N],
+                                > as ::zerocopy::TryFromBytes>::is_bit_valid(
+                                    field_candidate,
+                                )
+                            }
+                            && {
+                                let field_candidate = ::zerocopy::into_inner!(
+                                    candidate.reborrow().project:: < _, {
+                                    ::zerocopy::STRUCT_VARIANT_ID }, { ::zerocopy::ident_id!(4)
+                                    } > ()
+                                );
+                                <::zerocopy::util::macro_util::core_reexport::marker::PhantomData<
+                                    ComplexWithGenerics<'a, N, X, Y>,
+                                > as ::zerocopy::TryFromBytes>::is_bit_valid(
+                                    field_candidate,
+                                )
+                            }
+                    }
+                }
+                #[allow(
+                    deprecated,
+                    private_bounds,
+                    non_local_definitions,
+                    non_camel_case_types,
+                    non_upper_case_globals,
+                    non_snake_case,
+                    non_ascii_idents,
+                    clippy::missing_inline_in_public_items,
+                )]
+                #[deny(ambiguous_associated_items)]
+                #[automatically_derived]
+                const _: () = {
+                    enum ẕ0 {}
+                    enum ẕ1 {}
+                    enum ẕ2 {}
+                    enum ẕ3 {}
+                    enum ẕ4 {}
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            const N: usize,
+                        > ::zerocopy::HasTag
+                        for ___ZerocopyVariantStruct_TupleLike<'a, { N }, X, Y>
+                        where
+                            X: Deref<Target = &'a [(X, Y); N]>,
+                        {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Tag = ();
+                            type ProjectToTag = ::zerocopy::pointer::cast::CastToUnit;
+                        }
+                    };
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            const N: usize,
+                        > ::zerocopy::HasField<
+                            ẕ0,
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(0) },
+                        > for ___ZerocopyVariantStruct_TupleLike<'a, { N }, X, Y>
+                        where
+                            X: Deref<Target = &'a [(X, Y); N]>,
+                        {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Type = ::zerocopy::util::macro_util::core_reexport::mem::MaybeUninit<
+                                ___ZerocopyInnerTag,
+                            >;
+                            #[inline(always)]
+                            fn project(
+                                slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                            ) -> *mut <Self as ::zerocopy::HasField<
+                                ẕ0,
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(0) },
+                            >>::Type {
+                                let slf = slf.as_ptr();
+                                unsafe {
+                                    ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                        (* slf).0
+                                    )
+                                }
+                            }
+                        }
+                        #[allow(
+                            deprecated,
+                            private_bounds,
+                            non_local_definitions,
+                            non_camel_case_types,
+                            non_upper_case_globals,
+                            non_snake_case,
+                            non_ascii_idents,
+                            clippy::missing_inline_in_public_items,
+                        )]
+                        #[deny(ambiguous_associated_items)]
+                        #[automatically_derived]
+                        const _: () = {
+                            unsafe impl<
+                                'a: 'static,
+                                X,
+                                Y: Deref,
+                                Aliasing: ::zerocopy::invariant::Aliasing,
+                                Alignment: ::zerocopy::invariant::Alignment,
+                                const N: usize,
+                            > ::zerocopy::ProjectField<
+                                ẕ0,
+                                (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(0) },
+                            > for ___ZerocopyVariantStruct_TupleLike<'a, { N }, X, Y>
+                            where
+                                X: Deref<Target = &'a [(X, Y); N]>,
+                            {
+                                fn only_derive_is_allowed_to_implement_this_trait() {}
+                                type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                                type Invariants = (
+                                    Aliasing,
+                                    Alignment,
+                                    ::zerocopy::invariant::Initialized,
+                                );
+                            }
+                        };
+                    };
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            const N: usize,
+                        > ::zerocopy::HasField<
+                            ẕ1,
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(1) },
+                        > for ___ZerocopyVariantStruct_TupleLike<'a, { N }, X, Y>
+                        where
+                            X: Deref<Target = &'a [(X, Y); N]>,
+                        {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Type = bool;
+                            #[inline(always)]
+                            fn project(
+                                slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                            ) -> *mut <Self as ::zerocopy::HasField<
+                                ẕ1,
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(1) },
+                            >>::Type {
+                                let slf = slf.as_ptr();
+                                unsafe {
+                                    ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                        (* slf).1
+                                    )
+                                }
+                            }
+                        }
+                        #[allow(
+                            deprecated,
+                            private_bounds,
+                            non_local_definitions,
+                            non_camel_case_types,
+                            non_upper_case_globals,
+                            non_snake_case,
+                            non_ascii_idents,
+                            clippy::missing_inline_in_public_items,
+                        )]
+                        #[deny(ambiguous_associated_items)]
+                        #[automatically_derived]
+                        const _: () = {
+                            unsafe impl<
+                                'a: 'static,
+                                X,
+                                Y: Deref,
+                                Aliasing: ::zerocopy::invariant::Aliasing,
+                                Alignment: ::zerocopy::invariant::Alignment,
+                                const N: usize,
+                            > ::zerocopy::ProjectField<
+                                ẕ1,
+                                (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(1) },
+                            > for ___ZerocopyVariantStruct_TupleLike<'a, { N }, X, Y>
+                            where
+                                X: Deref<Target = &'a [(X, Y); N]>,
+                            {
+                                fn only_derive_is_allowed_to_implement_this_trait() {}
+                                type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                                type Invariants = (
+                                    Aliasing,
+                                    Alignment,
+                                    ::zerocopy::invariant::Initialized,
+                                );
+                            }
+                        };
+                    };
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            const N: usize,
+                        > ::zerocopy::HasField<
+                            ẕ2,
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(2) },
+                        > for ___ZerocopyVariantStruct_TupleLike<'a, { N }, X, Y>
+                        where
+                            X: Deref<Target = &'a [(X, Y); N]>,
+                        {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Type = Y;
+                            #[inline(always)]
+                            fn project(
+                                slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                            ) -> *mut <Self as ::zerocopy::HasField<
+                                ẕ2,
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(2) },
+                            >>::Type {
+                                let slf = slf.as_ptr();
+                                unsafe {
+                                    ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                        (* slf).2
+                                    )
+                                }
+                            }
+                        }
+                        #[allow(
+                            deprecated,
+                            private_bounds,
+                            non_local_definitions,
+                            non_camel_case_types,
+                            non_upper_case_globals,
+                            non_snake_case,
+                            non_ascii_idents,
+                            clippy::missing_inline_in_public_items,
+                        )]
+                        #[deny(ambiguous_associated_items)]
+                        #[automatically_derived]
+                        const _: () = {
+                            unsafe impl<
+                                'a: 'static,
+                                X,
+                                Y: Deref,
+                                Aliasing: ::zerocopy::invariant::Aliasing,
+                                Alignment: ::zerocopy::invariant::Alignment,
+                                const N: usize,
+                            > ::zerocopy::ProjectField<
+                                ẕ2,
+                                (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(2) },
+                            > for ___ZerocopyVariantStruct_TupleLike<'a, { N }, X, Y>
+                            where
+                                X: Deref<Target = &'a [(X, Y); N]>,
+                            {
+                                fn only_derive_is_allowed_to_implement_this_trait() {}
+                                type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                                type Invariants = (
+                                    Aliasing,
+                                    Alignment,
+                                    ::zerocopy::invariant::Initialized,
+                                );
+                            }
+                        };
+                    };
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            const N: usize,
+                        > ::zerocopy::HasField<
+                            ẕ3,
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(3) },
+                        > for ___ZerocopyVariantStruct_TupleLike<'a, { N }, X, Y>
+                        where
+                            X: Deref<Target = &'a [(X, Y); N]>,
+                        {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Type = PhantomData<&'a [(X, Y); N]>;
+                            #[inline(always)]
+                            fn project(
+                                slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                            ) -> *mut <Self as ::zerocopy::HasField<
+                                ẕ3,
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(3) },
+                            >>::Type {
+                                let slf = slf.as_ptr();
+                                unsafe {
+                                    ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                        (* slf).3
+                                    )
+                                }
+                            }
+                        }
+                        #[allow(
+                            deprecated,
+                            private_bounds,
+                            non_local_definitions,
+                            non_camel_case_types,
+                            non_upper_case_globals,
+                            non_snake_case,
+                            non_ascii_idents,
+                            clippy::missing_inline_in_public_items,
+                        )]
+                        #[deny(ambiguous_associated_items)]
+                        #[automatically_derived]
+                        const _: () = {
+                            unsafe impl<
+                                'a: 'static,
+                                X,
+                                Y: Deref,
+                                Aliasing: ::zerocopy::invariant::Aliasing,
+                                Alignment: ::zerocopy::invariant::Alignment,
+                                const N: usize,
+                            > ::zerocopy::ProjectField<
+                                ẕ3,
+                                (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(3) },
+                            > for ___ZerocopyVariantStruct_TupleLike<'a, { N }, X, Y>
+                            where
+                                X: Deref<Target = &'a [(X, Y); N]>,
+                            {
+                                fn only_derive_is_allowed_to_implement_this_trait() {}
+                                type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                                type Invariants = (
+                                    Aliasing,
+                                    Alignment,
+                                    ::zerocopy::invariant::Initialized,
+                                );
+                            }
+                        };
+                    };
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            const N: usize,
+                        > ::zerocopy::HasField<
+                            ẕ4,
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(4) },
+                        > for ___ZerocopyVariantStruct_TupleLike<'a, { N }, X, Y>
+                        where
+                            X: Deref<Target = &'a [(X, Y); N]>,
+                        {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Type = ::zerocopy::util::macro_util::core_reexport::marker::PhantomData<
+                                ComplexWithGenerics<'a, N, X, Y>,
+                            >;
+                            #[inline(always)]
+                            fn project(
+                                slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                            ) -> *mut <Self as ::zerocopy::HasField<
+                                ẕ4,
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(4) },
+                            >>::Type {
+                                let slf = slf.as_ptr();
+                                unsafe {
+                                    ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                        (* slf).4
+                                    )
+                                }
+                            }
+                        }
+                        #[allow(
+                            deprecated,
+                            private_bounds,
+                            non_local_definitions,
+                            non_camel_case_types,
+                            non_upper_case_globals,
+                            non_snake_case,
+                            non_ascii_idents,
+                            clippy::missing_inline_in_public_items,
+                        )]
+                        #[deny(ambiguous_associated_items)]
+                        #[automatically_derived]
+                        const _: () = {
+                            unsafe impl<
+                                'a: 'static,
+                                X,
+                                Y: Deref,
+                                Aliasing: ::zerocopy::invariant::Aliasing,
+                                Alignment: ::zerocopy::invariant::Alignment,
+                                const N: usize,
+                            > ::zerocopy::ProjectField<
+                                ẕ4,
+                                (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                                { ::zerocopy::STRUCT_VARIANT_ID },
+                                { ::zerocopy::ident_id!(4) },
+                            > for ___ZerocopyVariantStruct_TupleLike<'a, { N }, X, Y>
+                            where
+                                X: Deref<Target = &'a [(X, Y); N]>,
+                            {
+                                fn only_derive_is_allowed_to_implement_this_trait() {}
+                                type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                                type Invariants = (
+                                    Aliasing,
+                                    Alignment,
+                                    ::zerocopy::invariant::Initialized,
+                                );
+                            }
+                        };
+                    };
+                };
+            };
+            #[repr(C)]
+            union ___ZerocopyVariants<'a: 'static, const N: usize, X, Y: Deref> {
+                __field_StructLike: ::zerocopy::util::macro_util::core_reexport::mem::ManuallyDrop<
+                    ___ZerocopyVariantStruct_StructLike<'a, N, X, Y>,
+                >,
+                __field_TupleLike: ::zerocopy::util::macro_util::core_reexport::mem::ManuallyDrop<
+                    ___ZerocopyVariantStruct_TupleLike<'a, N, X, Y>,
+                >,
+                __nonempty: (),
+            }
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                enum ẕ__field_StructLike {}
+                enum ẕ__field_TupleLike {}
+                enum ẕ__nonempty {}
+                #[allow(
+                    deprecated,
+                    private_bounds,
+                    non_local_definitions,
+                    non_camel_case_types,
+                    non_upper_case_globals,
+                    non_snake_case,
+                    non_ascii_idents,
+                    clippy::missing_inline_in_public_items,
+                )]
+                #[deny(ambiguous_associated_items)]
+                #[automatically_derived]
+                const _: () = {
+                    unsafe impl<
+                        'a: 'static,
+                        X,
+                        Y: Deref,
+                        const N: usize,
+                    > ::zerocopy::HasTag for ___ZerocopyVariants<'a, { N }, X, Y> {
+                        fn only_derive_is_allowed_to_implement_this_trait() {}
+                        type Tag = ();
+                        type ProjectToTag = ::zerocopy::pointer::cast::CastToUnit;
+                    }
+                };
+                #[allow(
+                    deprecated,
+                    private_bounds,
+                    non_local_definitions,
+                    non_camel_case_types,
+                    non_upper_case_globals,
+                    non_snake_case,
+                    non_ascii_idents,
+                    clippy::missing_inline_in_public_items,
+                )]
+                #[deny(ambiguous_associated_items)]
+                #[automatically_derived]
+                const _: () = {
+                    unsafe impl<
+                        'a: 'static,
+                        X,
+                        Y: Deref,
+                        const N: usize,
+                    > ::zerocopy::HasField<
+                        ẕ__field_StructLike,
+                        { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                        { ::zerocopy::ident_id!(__field_StructLike) },
+                    > for ___ZerocopyVariants<'a, { N }, X, Y> {
+                        fn only_derive_is_allowed_to_implement_this_trait() {}
+                        type Type = ::zerocopy::util::macro_util::core_reexport::mem::ManuallyDrop<
+                            ___ZerocopyVariantStruct_StructLike<'a, N, X, Y>,
+                        >;
+                        #[inline(always)]
+                        fn project(
+                            slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                        ) -> *mut <Self as ::zerocopy::HasField<
+                            ẕ__field_StructLike,
+                            { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                            { ::zerocopy::ident_id!(__field_StructLike) },
+                        >>::Type {
+                            let slf = slf.as_ptr();
+                            unsafe {
+                                ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                    (* slf).__field_StructLike
+                                )
+                            }
+                        }
+                    }
+                };
+                #[allow(
+                    deprecated,
+                    private_bounds,
+                    non_local_definitions,
+                    non_camel_case_types,
+                    non_upper_case_globals,
+                    non_snake_case,
+                    non_ascii_idents,
+                    clippy::missing_inline_in_public_items,
+                )]
+                #[deny(ambiguous_associated_items)]
+                #[automatically_derived]
+                const _: () = {
+                    unsafe impl<
+                        'a: 'static,
+                        X,
+                        Y: Deref,
+                        const N: usize,
+                    > ::zerocopy::HasField<
+                        ẕ__field_TupleLike,
+                        { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                        { ::zerocopy::ident_id!(__field_TupleLike) },
+                    > for ___ZerocopyVariants<'a, { N }, X, Y> {
+                        fn only_derive_is_allowed_to_implement_this_trait() {}
+                        type Type = ::zerocopy::util::macro_util::core_reexport::mem::ManuallyDrop<
+                            ___ZerocopyVariantStruct_TupleLike<'a, N, X, Y>,
+                        >;
+                        #[inline(always)]
+                        fn project(
+                            slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                        ) -> *mut <Self as ::zerocopy::HasField<
+                            ẕ__field_TupleLike,
+                            { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                            { ::zerocopy::ident_id!(__field_TupleLike) },
+                        >>::Type {
+                            let slf = slf.as_ptr();
+                            unsafe {
+                                ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                    (* slf).__field_TupleLike
+                                )
+                            }
+                        }
+                    }
+                };
+                #[allow(
+                    deprecated,
+                    private_bounds,
+                    non_local_definitions,
+                    non_camel_case_types,
+                    non_upper_case_globals,
+                    non_snake_case,
+                    non_ascii_idents,
+                    clippy::missing_inline_in_public_items,
+                )]
+                #[deny(ambiguous_associated_items)]
+                #[automatically_derived]
+                const _: () = {
+                    unsafe impl<
+                        'a: 'static,
+                        X,
+                        Y: Deref,
+                        const N: usize,
+                    > ::zerocopy::HasField<
+                        ẕ__nonempty,
+                        { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                        { ::zerocopy::ident_id!(__nonempty) },
+                    > for ___ZerocopyVariants<'a, { N }, X, Y> {
+                        fn only_derive_is_allowed_to_implement_this_trait() {}
+                        type Type = ();
+                        #[inline(always)]
+                        fn project(
+                            slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                        ) -> *mut <Self as ::zerocopy::HasField<
+                            ẕ__nonempty,
+                            { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                            { ::zerocopy::ident_id!(__nonempty) },
+                        >>::Type {
+                            let slf = slf.as_ptr();
+                            unsafe {
+                                ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                    (* slf).__nonempty
+                                )
+                            }
+                        }
+                    }
+                };
+            };
+            #[repr(C)]
+            struct ___ZerocopyRawEnum<'a: 'static, const N: usize, X, Y: Deref> {
+                tag: ___ZerocopyOuterTag,
+                variants: ___ZerocopyVariants<'a, N, X, Y>,
+            }
+            unsafe impl<
+                'a: 'static,
+                const N: usize,
+                X,
+                Y: Deref,
+            > ::zerocopy::pointer::InvariantsEq<___ZerocopyRawEnum<'a, N, X, Y>>
+            for ComplexWithGenerics<'a, N, X, Y>
+            where
+                X: Deref<Target = &'a [(X, Y); N]>,
+            {}
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                enum ẕtag {}
+                enum ẕvariants {}
+                #[allow(
+                    deprecated,
+                    private_bounds,
+                    non_local_definitions,
+                    non_camel_case_types,
+                    non_upper_case_globals,
+                    non_snake_case,
+                    non_ascii_idents,
+                    clippy::missing_inline_in_public_items,
+                )]
+                #[deny(ambiguous_associated_items)]
+                #[automatically_derived]
+                const _: () = {
+                    unsafe impl<
+                        'a: 'static,
+                        X,
+                        Y: Deref,
+                        const N: usize,
+                    > ::zerocopy::HasTag for ___ZerocopyRawEnum<'a, { N }, X, Y> {
+                        fn only_derive_is_allowed_to_implement_this_trait() {}
+                        type Tag = ();
+                        type ProjectToTag = ::zerocopy::pointer::cast::CastToUnit;
+                    }
+                };
+                #[allow(
+                    deprecated,
+                    private_bounds,
+                    non_local_definitions,
+                    non_camel_case_types,
+                    non_upper_case_globals,
+                    non_snake_case,
+                    non_ascii_idents,
+                    clippy::missing_inline_in_public_items,
+                )]
+                #[deny(ambiguous_associated_items)]
+                #[automatically_derived]
+                const _: () = {
+                    unsafe impl<
+                        'a: 'static,
+                        X,
+                        Y: Deref,
+                        const N: usize,
+                    > ::zerocopy::HasField<
+                        ẕtag,
+                        { ::zerocopy::STRUCT_VARIANT_ID },
+                        { ::zerocopy::ident_id!(tag) },
+                    > for ___ZerocopyRawEnum<'a, { N }, X, Y> {
+                        fn only_derive_is_allowed_to_implement_this_trait() {}
+                        type Type = ___ZerocopyOuterTag;
+                        #[inline(always)]
+                        fn project(
+                            slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                        ) -> *mut <Self as ::zerocopy::HasField<
+                            ẕtag,
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(tag) },
+                        >>::Type {
+                            let slf = slf.as_ptr();
+                            unsafe {
+                                ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                    (* slf).tag
+                                )
+                            }
+                        }
+                    }
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            Aliasing: ::zerocopy::invariant::Aliasing,
+                            Alignment: ::zerocopy::invariant::Alignment,
+                            const N: usize,
+                        > ::zerocopy::ProjectField<
+                            ẕtag,
+                            (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(tag) },
+                        > for ___ZerocopyRawEnum<'a, { N }, X, Y> {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                            type Invariants = (
+                                Aliasing,
+                                Alignment,
+                                ::zerocopy::invariant::Initialized,
+                            );
+                        }
+                    };
+                };
+                #[allow(
+                    deprecated,
+                    private_bounds,
+                    non_local_definitions,
+                    non_camel_case_types,
+                    non_upper_case_globals,
+                    non_snake_case,
+                    non_ascii_idents,
+                    clippy::missing_inline_in_public_items,
+                )]
+                #[deny(ambiguous_associated_items)]
+                #[automatically_derived]
+                const _: () = {
+                    unsafe impl<
+                        'a: 'static,
+                        X,
+                        Y: Deref,
+                        const N: usize,
+                    > ::zerocopy::HasField<
+                        ẕvariants,
+                        { ::zerocopy::STRUCT_VARIANT_ID },
+                        { ::zerocopy::ident_id!(variants) },
+                    > for ___ZerocopyRawEnum<'a, { N }, X, Y> {
+                        fn only_derive_is_allowed_to_implement_this_trait() {}
+                        type Type = ___ZerocopyVariants<'a, N, X, Y>;
+                        #[inline(always)]
+                        fn project(
+                            slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                        ) -> *mut <Self as ::zerocopy::HasField<
+                            ẕvariants,
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(variants) },
+                        >>::Type {
+                            let slf = slf.as_ptr();
+                            unsafe {
+                                ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                                    (* slf).variants
+                                )
+                            }
+                        }
+                    }
+                    #[allow(
+                        deprecated,
+                        private_bounds,
+                        non_local_definitions,
+                        non_camel_case_types,
+                        non_upper_case_globals,
+                        non_snake_case,
+                        non_ascii_idents,
+                        clippy::missing_inline_in_public_items,
+                    )]
+                    #[deny(ambiguous_associated_items)]
+                    #[automatically_derived]
+                    const _: () = {
+                        unsafe impl<
+                            'a: 'static,
+                            X,
+                            Y: Deref,
+                            Aliasing: ::zerocopy::invariant::Aliasing,
+                            Alignment: ::zerocopy::invariant::Alignment,
+                            const N: usize,
+                        > ::zerocopy::ProjectField<
+                            ẕvariants,
+                            (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                            { ::zerocopy::STRUCT_VARIANT_ID },
+                            { ::zerocopy::ident_id!(variants) },
+                        > for ___ZerocopyRawEnum<'a, { N }, X, Y> {
+                            fn only_derive_is_allowed_to_implement_this_trait() {}
+                            type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                            type Invariants = (
+                                Aliasing,
+                                Alignment,
+                                ::zerocopy::invariant::Initialized,
+                            );
+                        }
+                    };
+                };
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<'a: 'static, X, Y: Deref, const N: usize> ::zerocopy::HasTag
+                for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Tag = ___ZerocopyTag;
+                    type ProjectToTag = ::zerocopy::pointer::cast::CastSized;
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    const N: usize,
+                > ::zerocopy::HasField<
+                    (),
+                    { ::zerocopy::ident_id!(StructLike) },
+                    { ::zerocopy::ident_id!(a) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Type = u8;
+                    #[inline(always)]
+                    fn project(
+                        slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                    ) -> *mut <Self as ::zerocopy::HasField<
+                        (),
+                        { ::zerocopy::ident_id!(StructLike) },
+                        { ::zerocopy::ident_id!(a) },
+                    >>::Type {
+                        use ::zerocopy::pointer::cast::{CastSized, Projection};
+                        slf.project::<___ZerocopyRawEnum<'a, N, X, Y>, CastSized>()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(variants) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(__field_StructLike) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(value) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(1) },
+                                >,
+                            >()
+                            .as_ptr()
+                    }
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    Aliasing: ::zerocopy::invariant::Aliasing,
+                    Alignment: ::zerocopy::invariant::Alignment,
+                    const N: usize,
+                > ::zerocopy::ProjectField<
+                    (),
+                    (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                    { ::zerocopy::ident_id!(StructLike) },
+                    { ::zerocopy::ident_id!(a) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                    type Invariants = (
+                        Aliasing,
+                        Alignment,
+                        ::zerocopy::invariant::Initialized,
+                    );
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    const N: usize,
+                > ::zerocopy::HasField<
+                    (),
+                    { ::zerocopy::ident_id!(StructLike) },
+                    { ::zerocopy::ident_id!(b) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Type = X;
+                    #[inline(always)]
+                    fn project(
+                        slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                    ) -> *mut <Self as ::zerocopy::HasField<
+                        (),
+                        { ::zerocopy::ident_id!(StructLike) },
+                        { ::zerocopy::ident_id!(b) },
+                    >>::Type {
+                        use ::zerocopy::pointer::cast::{CastSized, Projection};
+                        slf.project::<___ZerocopyRawEnum<'a, N, X, Y>, CastSized>()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(variants) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(__field_StructLike) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(value) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(2) },
+                                >,
+                            >()
+                            .as_ptr()
+                    }
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    Aliasing: ::zerocopy::invariant::Aliasing,
+                    Alignment: ::zerocopy::invariant::Alignment,
+                    const N: usize,
+                > ::zerocopy::ProjectField<
+                    (),
+                    (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                    { ::zerocopy::ident_id!(StructLike) },
+                    { ::zerocopy::ident_id!(b) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                    type Invariants = (
+                        Aliasing,
+                        Alignment,
+                        ::zerocopy::invariant::Initialized,
+                    );
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    const N: usize,
+                > ::zerocopy::HasField<
+                    (),
+                    { ::zerocopy::ident_id!(StructLike) },
+                    { ::zerocopy::ident_id!(c) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Type = X::Target;
+                    #[inline(always)]
+                    fn project(
+                        slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                    ) -> *mut <Self as ::zerocopy::HasField<
+                        (),
+                        { ::zerocopy::ident_id!(StructLike) },
+                        { ::zerocopy::ident_id!(c) },
+                    >>::Type {
+                        use ::zerocopy::pointer::cast::{CastSized, Projection};
+                        slf.project::<___ZerocopyRawEnum<'a, N, X, Y>, CastSized>()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(variants) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(__field_StructLike) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(value) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(3) },
+                                >,
+                            >()
+                            .as_ptr()
+                    }
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    Aliasing: ::zerocopy::invariant::Aliasing,
+                    Alignment: ::zerocopy::invariant::Alignment,
+                    const N: usize,
+                > ::zerocopy::ProjectField<
+                    (),
+                    (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                    { ::zerocopy::ident_id!(StructLike) },
+                    { ::zerocopy::ident_id!(c) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                    type Invariants = (
+                        Aliasing,
+                        Alignment,
+                        ::zerocopy::invariant::Initialized,
+                    );
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    const N: usize,
+                > ::zerocopy::HasField<
+                    (),
+                    { ::zerocopy::ident_id!(StructLike) },
+                    { ::zerocopy::ident_id!(d) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Type = Y::Target;
+                    #[inline(always)]
+                    fn project(
+                        slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                    ) -> *mut <Self as ::zerocopy::HasField<
+                        (),
+                        { ::zerocopy::ident_id!(StructLike) },
+                        { ::zerocopy::ident_id!(d) },
+                    >>::Type {
+                        use ::zerocopy::pointer::cast::{CastSized, Projection};
+                        slf.project::<___ZerocopyRawEnum<'a, N, X, Y>, CastSized>()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(variants) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(__field_StructLike) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(value) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(4) },
+                                >,
+                            >()
+                            .as_ptr()
+                    }
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    Aliasing: ::zerocopy::invariant::Aliasing,
+                    Alignment: ::zerocopy::invariant::Alignment,
+                    const N: usize,
+                > ::zerocopy::ProjectField<
+                    (),
+                    (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                    { ::zerocopy::ident_id!(StructLike) },
+                    { ::zerocopy::ident_id!(d) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                    type Invariants = (
+                        Aliasing,
+                        Alignment,
+                        ::zerocopy::invariant::Initialized,
+                    );
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    const N: usize,
+                > ::zerocopy::HasField<
+                    (),
+                    { ::zerocopy::ident_id!(StructLike) },
+                    { ::zerocopy::ident_id!(e) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Type = [(X, Y); N];
+                    #[inline(always)]
+                    fn project(
+                        slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                    ) -> *mut <Self as ::zerocopy::HasField<
+                        (),
+                        { ::zerocopy::ident_id!(StructLike) },
+                        { ::zerocopy::ident_id!(e) },
+                    >>::Type {
+                        use ::zerocopy::pointer::cast::{CastSized, Projection};
+                        slf.project::<___ZerocopyRawEnum<'a, N, X, Y>, CastSized>()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(variants) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(__field_StructLike) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(value) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(5) },
+                                >,
+                            >()
+                            .as_ptr()
+                    }
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    Aliasing: ::zerocopy::invariant::Aliasing,
+                    Alignment: ::zerocopy::invariant::Alignment,
+                    const N: usize,
+                > ::zerocopy::ProjectField<
+                    (),
+                    (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                    { ::zerocopy::ident_id!(StructLike) },
+                    { ::zerocopy::ident_id!(e) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                    type Invariants = (
+                        Aliasing,
+                        Alignment,
+                        ::zerocopy::invariant::Initialized,
+                    );
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    const N: usize,
+                > ::zerocopy::HasField<
+                    (),
+                    { ::zerocopy::ident_id!(TupleLike) },
+                    { ::zerocopy::ident_id!(0) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Type = bool;
+                    #[inline(always)]
+                    fn project(
+                        slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                    ) -> *mut <Self as ::zerocopy::HasField<
+                        (),
+                        { ::zerocopy::ident_id!(TupleLike) },
+                        { ::zerocopy::ident_id!(0) },
+                    >>::Type {
+                        use ::zerocopy::pointer::cast::{CastSized, Projection};
+                        slf.project::<___ZerocopyRawEnum<'a, N, X, Y>, CastSized>()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(variants) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(__field_TupleLike) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(value) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(1) },
+                                >,
+                            >()
+                            .as_ptr()
+                    }
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    Aliasing: ::zerocopy::invariant::Aliasing,
+                    Alignment: ::zerocopy::invariant::Alignment,
+                    const N: usize,
+                > ::zerocopy::ProjectField<
+                    (),
+                    (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                    { ::zerocopy::ident_id!(TupleLike) },
+                    { ::zerocopy::ident_id!(0) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                    type Invariants = (
+                        Aliasing,
+                        Alignment,
+                        ::zerocopy::invariant::Initialized,
+                    );
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    const N: usize,
+                > ::zerocopy::HasField<
+                    (),
+                    { ::zerocopy::ident_id!(TupleLike) },
+                    { ::zerocopy::ident_id!(1) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Type = Y;
+                    #[inline(always)]
+                    fn project(
+                        slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                    ) -> *mut <Self as ::zerocopy::HasField<
+                        (),
+                        { ::zerocopy::ident_id!(TupleLike) },
+                        { ::zerocopy::ident_id!(1) },
+                    >>::Type {
+                        use ::zerocopy::pointer::cast::{CastSized, Projection};
+                        slf.project::<___ZerocopyRawEnum<'a, N, X, Y>, CastSized>()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(variants) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(__field_TupleLike) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(value) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(2) },
+                                >,
+                            >()
+                            .as_ptr()
+                    }
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    Aliasing: ::zerocopy::invariant::Aliasing,
+                    Alignment: ::zerocopy::invariant::Alignment,
+                    const N: usize,
+                > ::zerocopy::ProjectField<
+                    (),
+                    (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                    { ::zerocopy::ident_id!(TupleLike) },
+                    { ::zerocopy::ident_id!(1) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                    type Invariants = (
+                        Aliasing,
+                        Alignment,
+                        ::zerocopy::invariant::Initialized,
+                    );
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    const N: usize,
+                > ::zerocopy::HasField<
+                    (),
+                    { ::zerocopy::ident_id!(TupleLike) },
+                    { ::zerocopy::ident_id!(2) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Type = PhantomData<&'a [(X, Y); N]>;
+                    #[inline(always)]
+                    fn project(
+                        slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                    ) -> *mut <Self as ::zerocopy::HasField<
+                        (),
+                        { ::zerocopy::ident_id!(TupleLike) },
+                        { ::zerocopy::ident_id!(2) },
+                    >>::Type {
+                        use ::zerocopy::pointer::cast::{CastSized, Projection};
+                        slf.project::<___ZerocopyRawEnum<'a, N, X, Y>, CastSized>()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(variants) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(__field_TupleLike) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(value) },
+                                >,
+                            >()
+                            .project::<
+                                _,
+                                Projection<
+                                    _,
+                                    { ::zerocopy::STRUCT_VARIANT_ID },
+                                    { ::zerocopy::ident_id!(3) },
+                                >,
+                            >()
+                            .as_ptr()
+                    }
+                }
+            };
+            #[allow(
+                deprecated,
+                private_bounds,
+                non_local_definitions,
+                non_camel_case_types,
+                non_upper_case_globals,
+                non_snake_case,
+                non_ascii_idents,
+                clippy::missing_inline_in_public_items,
+            )]
+            #[deny(ambiguous_associated_items)]
+            #[automatically_derived]
+            const _: () = {
+                unsafe impl<
+                    'a: 'static,
+                    X,
+                    Y: Deref,
+                    Aliasing: ::zerocopy::invariant::Aliasing,
+                    Alignment: ::zerocopy::invariant::Alignment,
+                    const N: usize,
+                > ::zerocopy::ProjectField<
+                    (),
+                    (Aliasing, Alignment, ::zerocopy::invariant::Initialized),
+                    { ::zerocopy::ident_id!(TupleLike) },
+                    { ::zerocopy::ident_id!(2) },
+                > for ComplexWithGenerics<'a, { N }, X, Y>
+                where
+                    X: Deref<Target = &'a [(X, Y); N]>,
+                {
+                    fn only_derive_is_allowed_to_implement_this_trait() {}
+                    type Error = ::zerocopy::util::macro_util::core_reexport::convert::Infallible;
+                    type Invariants = (
+                        Aliasing,
+                        Alignment,
+                        ::zerocopy::invariant::Initialized,
+                    );
+                }
+            };
+            let tag = {
+                let tag_ptr = unsafe {
+                    candidate
+                        .reborrow()
+                        .project_transmute_unchecked::<
+                            _,
+                            ::zerocopy::invariant::Initialized,
+                            ::zerocopy::pointer::cast::CastSized,
+                        >()
+                };
+                tag_ptr
+                    .recall_validity::<_, (_, (_, _))>()
+                    .read_unaligned::<::zerocopy::BecauseImmutable>()
+            };
+            let mut raw_enum = candidate
+                .cast::<
+                    ::zerocopy::ReadOnly<___ZerocopyRawEnum<'a, N, X, Y>>,
+                    ::zerocopy::pointer::cast::CastSized,
+                    (::zerocopy::pointer::BecauseRead, _),
+                >();
+            let variants = ::zerocopy::into_inner!(
+                raw_enum.project:: < _, { ::zerocopy::STRUCT_VARIANT_ID }, {
+                ::zerocopy::ident_id!(variants) } > ()
+            );
+            match tag {
+                ___ZEROCOPY_TAG_UnitLike => true,
+                ___ZEROCOPY_TAG_StructLike => {
+                    let variant_md = variants
+                        .cast::<
+                            _,
+                            ::zerocopy::pointer::cast::Projection<
+                                _,
+                                { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                                { ::zerocopy::ident_id!(__field_StructLike) },
+                            >,
+                            _,
+                        >();
+                    let variant = variant_md
+                        .cast::<
+                            ::zerocopy::ReadOnly<
+                                ___ZerocopyVariantStruct_StructLike<'a, N, X, Y>,
+                            >,
+                            ::zerocopy::pointer::cast::CastSized,
+                            (::zerocopy::pointer::BecauseRead, _),
+                        >();
+                    <___ZerocopyVariantStruct_StructLike<
+                        'a,
+                        N,
+                        X,
+                        Y,
+                    > as ::zerocopy::TryFromBytes>::is_bit_valid(variant)
+                }
+                ___ZEROCOPY_TAG_TupleLike => {
+                    let variant_md = variants
+                        .cast::<
+                            _,
+                            ::zerocopy::pointer::cast::Projection<
+                                _,
+                                { ::zerocopy::REPR_C_UNION_VARIANT_ID },
+                                { ::zerocopy::ident_id!(__field_TupleLike) },
+                            >,
+                            _,
+                        >();
+                    let variant = variant_md
+                        .cast::<
+                            ::zerocopy::ReadOnly<
+                                ___ZerocopyVariantStruct_TupleLike<'a, N, X, Y>,
+                            >,
+                            ::zerocopy::pointer::cast::CastSized,
+                            (::zerocopy::pointer::BecauseRead, _),
+                        >();
+                    <___ZerocopyVariantStruct_TupleLike<
+                        'a,
+                        N,
+                        X,
+                        Y,
+                    > as ::zerocopy::TryFromBytes>::is_bit_valid(variant)
+                }
+                _ => false,
+            }
+        }
+    }
+};