tools/fidl/fidlgen_rust/goldens/padding.rs.golden

// WARNING: This file is machine generated by fidlgen.

// fidl_experiment = no_optional_structs
// fidl_experiment = output_index_json
// fidl_experiment = unknown_interactions
// fidl_experiment = unknown_interactions_mandate

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use {
    bitflags::bitflags,
    fidl::{
        client::QueryResponseFut,
        endpoints::{ControlHandle as _, Responder as _},
    },
    fuchsia_zircon_status as zx_status,
    futures::future::{self, MaybeDone, TryFutureExt},
};

#[cfg(target_os = "fuchsia")]
use fuchsia_zircon as zx;

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding1ByteEnd {
    pub a: u16,
    pub b: u8,
}

impl fidl::Persistable for Padding1ByteEnd {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding1ByteMiddle {
    pub a: u8,
    pub b: u16,
}

impl fidl::Persistable for Padding1ByteMiddle {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding2ByteAlignmentLength6 {
    pub a: u8,
    pub b: u16,
    pub c: u8,
}

impl fidl::Persistable for Padding2ByteAlignmentLength6 {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding2ByteEnd {
    pub a: u32,
    pub b: u16,
}

impl fidl::Persistable for Padding2ByteEnd {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding2ByteMiddle {
    pub a: u16,
    pub b: u32,
}

impl fidl::Persistable for Padding2ByteMiddle {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding3ByteEnd {
    pub a: u32,
    pub b: u8,
}

impl fidl::Persistable for Padding3ByteEnd {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding3ByteMiddle {
    pub a: u8,
    pub b: u32,
}

impl fidl::Persistable for Padding3ByteMiddle {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding4ByteAlignmentLength12 {
    pub a: u32,
    pub b: u8,
    pub c: u16,
    pub d: u16,
}

impl fidl::Persistable for Padding4ByteAlignmentLength12 {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding4ByteEnd {
    pub a: u64,
    pub b: u32,
}

impl fidl::Persistable for Padding4ByteEnd {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding4ByteMiddle {
    pub a: u32,
    pub b: u64,
}

impl fidl::Persistable for Padding4ByteMiddle {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding5ByteEnd {
    pub a: u64,
    pub b: u16,
    pub c: u8,
}

impl fidl::Persistable for Padding5ByteEnd {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding5ByteMiddle {
    pub a: u16,
    pub b: u8,
    pub c: u64,
}

impl fidl::Persistable for Padding5ByteMiddle {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding6ByteEnd {
    pub a: u64,
    pub b: u16,
}

impl fidl::Persistable for Padding6ByteEnd {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding6ByteMiddle {
    pub a: u16,
    pub b: u64,
}

impl fidl::Persistable for Padding6ByteMiddle {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding7ByteEnd {
    pub a: u64,
    pub b: u8,
}

impl fidl::Persistable for Padding7ByteEnd {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Padding7ByteMiddle {
    pub a: u8,
    pub b: u64,
}

impl fidl::Persistable for Padding7ByteMiddle {}

mod internal {
    use super::*;

    unsafe impl fidl::encoding::TypeMarker for Padding1ByteEnd {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 2,
                fidl::encoding::WireFormatVersion::V2 => 2,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 4,
                fidl::encoding::WireFormatVersion::V2 => 4,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding1ByteEnd {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding1ByteEnd> for &Padding1ByteEnd {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding1ByteEnd>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding1ByteEnd)
                    .write_unaligned((self as *const Padding1ByteEnd).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(2) as *mut u16;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xff00u16);
            }
            Ok(())
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<u16>, T1: fidl::encoding::Encode<u8>>
        fidl::encoding::Encode<Padding1ByteEnd> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding1ByteEnd>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2);
                    (ptr as *mut u16).write_unaligned(0);
                },
                fidl::encoding::WireFormatVersion::V2 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2);
                    (ptr as *mut u16).write_unaligned(0);
                },
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 2,
                fidl::encoding::WireFormatVersion::V2 => 2,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding1ByteEnd {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { a: fidl::new_empty!(u16), b: fidl::new_empty!(u8) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(2) };
            let padval = unsafe { (ptr as *const u16).read_unaligned() };
            let maskedval = padval & 0xff00u16;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 2 + ((0xff00u16 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Padding1ByteMiddle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 2,
                fidl::encoding::WireFormatVersion::V2 => 2,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 4,
                fidl::encoding::WireFormatVersion::V2 => 4,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding1ByteMiddle {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding1ByteMiddle> for &Padding1ByteMiddle {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding1ByteMiddle>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding1ByteMiddle)
                    .write_unaligned((self as *const Padding1ByteMiddle).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(0) as *mut u16;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xff00u16);
            }
            Ok(())
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<u8>, T1: fidl::encoding::Encode<u16>>
        fidl::encoding::Encode<Padding1ByteMiddle> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding1ByteMiddle>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                    (ptr as *mut u16).write_unaligned(0);
                },
                fidl::encoding::WireFormatVersion::V2 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                    (ptr as *mut u16).write_unaligned(0);
                },
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 2,
                fidl::encoding::WireFormatVersion::V2 => 2,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding1ByteMiddle {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { a: fidl::new_empty!(u8), b: fidl::new_empty!(u16) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(0) };
            let padval = unsafe { (ptr as *const u16).read_unaligned() };
            let maskedval = padval & 0xff00u16;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((0xff00u16 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Padding2ByteAlignmentLength6 {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 2,
                fidl::encoding::WireFormatVersion::V2 => 2,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 6,
                fidl::encoding::WireFormatVersion::V2 => 6,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding2ByteAlignmentLength6 {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding2ByteAlignmentLength6> for &Padding2ByteAlignmentLength6 {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding2ByteAlignmentLength6>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding2ByteAlignmentLength6)
                    .write_unaligned((self as *const Padding2ByteAlignmentLength6).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(0) as *mut u16;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xff00u16);
                let padding_ptr = buf_ptr.offset(4) as *mut u16;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xff00u16);
            }
            Ok(())
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u8>,
            T1: fidl::encoding::Encode<u16>,
            T2: fidl::encoding::Encode<u8>,
        > fidl::encoding::Encode<Padding2ByteAlignmentLength6> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding2ByteAlignmentLength6>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => {
                    unsafe {
                        let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                        (ptr as *mut u16).write_unaligned(0);
                    }
                    unsafe {
                        let ptr = encoder.buf.as_mut_ptr().add(offset).offset(4);
                        (ptr as *mut u16).write_unaligned(0);
                    }
                }
                fidl::encoding::WireFormatVersion::V2 => {
                    unsafe {
                        let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                        (ptr as *mut u16).write_unaligned(0);
                    }
                    unsafe {
                        let ptr = encoder.buf.as_mut_ptr().add(offset).offset(4);
                        (ptr as *mut u16).write_unaligned(0);
                    }
                }
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 2,
                fidl::encoding::WireFormatVersion::V2 => 2,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 4,
                fidl::encoding::WireFormatVersion::V2 => 4,
            };
            self.2.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding2ByteAlignmentLength6 {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { a: fidl::new_empty!(u8), b: fidl::new_empty!(u16), c: fidl::new_empty!(u8) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(0) };
            let padval = unsafe { (ptr as *const u16).read_unaligned() };
            let maskedval = padval & 0xff00u16;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((0xff00u16 as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { buf_ptr.offset(4) };
            let padval = unsafe { (ptr as *const u16).read_unaligned() };
            let maskedval = padval & 0xff00u16;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 4 + ((0xff00u16 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 6);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Padding2ByteEnd {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 4,
                fidl::encoding::WireFormatVersion::V2 => 4,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding2ByteEnd {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding2ByteEnd> for &Padding2ByteEnd {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding2ByteEnd>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding2ByteEnd)
                    .write_unaligned((self as *const Padding2ByteEnd).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(4) as *mut u32;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xffff0000u32);
            }
            Ok(())
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<u32>, T1: fidl::encoding::Encode<u16>>
        fidl::encoding::Encode<Padding2ByteEnd> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding2ByteEnd>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(4);
                    (ptr as *mut u32).write_unaligned(0);
                },
                fidl::encoding::WireFormatVersion::V2 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(4);
                    (ptr as *mut u32).write_unaligned(0);
                },
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 4,
                fidl::encoding::WireFormatVersion::V2 => 4,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding2ByteEnd {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { a: fidl::new_empty!(u32), b: fidl::new_empty!(u16) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(4) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let maskedval = padval & 0xffff0000u32;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 4
                        + ((0xffff0000u32 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Padding2ByteMiddle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 4,
                fidl::encoding::WireFormatVersion::V2 => 4,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding2ByteMiddle {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding2ByteMiddle> for &Padding2ByteMiddle {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding2ByteMiddle>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding2ByteMiddle)
                    .write_unaligned((self as *const Padding2ByteMiddle).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(0) as *mut u32;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xffff0000u32);
            }
            Ok(())
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<u16>, T1: fidl::encoding::Encode<u32>>
        fidl::encoding::Encode<Padding2ByteMiddle> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding2ByteMiddle>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                    (ptr as *mut u32).write_unaligned(0);
                },
                fidl::encoding::WireFormatVersion::V2 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                    (ptr as *mut u32).write_unaligned(0);
                },
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 4,
                fidl::encoding::WireFormatVersion::V2 => 4,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding2ByteMiddle {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { a: fidl::new_empty!(u16), b: fidl::new_empty!(u32) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(0) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let maskedval = padval & 0xffff0000u32;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 0
                        + ((0xffff0000u32 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Padding3ByteEnd {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 4,
                fidl::encoding::WireFormatVersion::V2 => 4,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding3ByteEnd {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding3ByteEnd> for &Padding3ByteEnd {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding3ByteEnd>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding3ByteEnd)
                    .write_unaligned((self as *const Padding3ByteEnd).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(4) as *mut u32;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xffffff00u32);
            }
            Ok(())
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<u32>, T1: fidl::encoding::Encode<u8>>
        fidl::encoding::Encode<Padding3ByteEnd> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding3ByteEnd>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(4);
                    (ptr as *mut u32).write_unaligned(0);
                },
                fidl::encoding::WireFormatVersion::V2 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(4);
                    (ptr as *mut u32).write_unaligned(0);
                },
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 4,
                fidl::encoding::WireFormatVersion::V2 => 4,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding3ByteEnd {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { a: fidl::new_empty!(u32), b: fidl::new_empty!(u8) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(4) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let maskedval = padval & 0xffffff00u32;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 4
                        + ((0xffffff00u32 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Padding3ByteMiddle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 4,
                fidl::encoding::WireFormatVersion::V2 => 4,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding3ByteMiddle {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding3ByteMiddle> for &Padding3ByteMiddle {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding3ByteMiddle>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding3ByteMiddle)
                    .write_unaligned((self as *const Padding3ByteMiddle).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(0) as *mut u32;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xffffff00u32);
            }
            Ok(())
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<u8>, T1: fidl::encoding::Encode<u32>>
        fidl::encoding::Encode<Padding3ByteMiddle> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding3ByteMiddle>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                    (ptr as *mut u32).write_unaligned(0);
                },
                fidl::encoding::WireFormatVersion::V2 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                    (ptr as *mut u32).write_unaligned(0);
                },
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 4,
                fidl::encoding::WireFormatVersion::V2 => 4,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding3ByteMiddle {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { a: fidl::new_empty!(u8), b: fidl::new_empty!(u32) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(0) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let maskedval = padval & 0xffffff00u32;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 0
                        + ((0xffffff00u32 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Padding4ByteAlignmentLength12 {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 4,
                fidl::encoding::WireFormatVersion::V2 => 4,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 12,
                fidl::encoding::WireFormatVersion::V2 => 12,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding4ByteAlignmentLength12 {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding4ByteAlignmentLength12>
        for &Padding4ByteAlignmentLength12
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding4ByteAlignmentLength12>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding4ByteAlignmentLength12)
                    .write_unaligned((self as *const Padding4ByteAlignmentLength12).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(4) as *mut u32;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0x0000ff00u32);
                let padding_ptr = buf_ptr.offset(8) as *mut u32;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xffff0000u32);
            }
            Ok(())
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u32>,
            T1: fidl::encoding::Encode<u8>,
            T2: fidl::encoding::Encode<u16>,
            T3: fidl::encoding::Encode<u16>,
        > fidl::encoding::Encode<Padding4ByteAlignmentLength12> for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding4ByteAlignmentLength12>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => {
                    unsafe {
                        let ptr = encoder.buf.as_mut_ptr().add(offset).offset(4);
                        (ptr as *mut u32).write_unaligned(0);
                    }
                    unsafe {
                        let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                        (ptr as *mut u32).write_unaligned(0);
                    }
                }
                fidl::encoding::WireFormatVersion::V2 => {
                    unsafe {
                        let ptr = encoder.buf.as_mut_ptr().add(offset).offset(4);
                        (ptr as *mut u32).write_unaligned(0);
                    }
                    unsafe {
                        let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                        (ptr as *mut u32).write_unaligned(0);
                    }
                }
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 4,
                fidl::encoding::WireFormatVersion::V2 => 4,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 6,
                fidl::encoding::WireFormatVersion::V2 => 6,
            };
            self.2.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            };
            self.3.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding4ByteAlignmentLength12 {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                a: fidl::new_empty!(u32),
                b: fidl::new_empty!(u8),
                c: fidl::new_empty!(u16),
                d: fidl::new_empty!(u16),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(4) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let maskedval = padval & 0x0000ff00u32;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 4
                        + ((0x0000ff00u32 as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { buf_ptr.offset(8) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let maskedval = padval & 0xffff0000u32;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 8
                        + ((0xffff0000u32 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 12);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Padding4ByteEnd {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 16,
                fidl::encoding::WireFormatVersion::V2 => 16,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding4ByteEnd {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding4ByteEnd> for &Padding4ByteEnd {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding4ByteEnd>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding4ByteEnd)
                    .write_unaligned((self as *const Padding4ByteEnd).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(8) as *mut u64;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xffffffff00000000u64);
            }
            Ok(())
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<u64>, T1: fidl::encoding::Encode<u32>>
        fidl::encoding::Encode<Padding4ByteEnd> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding4ByteEnd>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                    (ptr as *mut u64).write_unaligned(0);
                },
                fidl::encoding::WireFormatVersion::V2 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                    (ptr as *mut u64).write_unaligned(0);
                },
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding4ByteEnd {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { a: fidl::new_empty!(u64), b: fidl::new_empty!(u32) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let maskedval = padval & 0xffffffff00000000u64;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 8
                        + ((0xffffffff00000000u64 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Padding4ByteMiddle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 16,
                fidl::encoding::WireFormatVersion::V2 => 16,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding4ByteMiddle {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding4ByteMiddle> for &Padding4ByteMiddle {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding4ByteMiddle>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding4ByteMiddle)
                    .write_unaligned((self as *const Padding4ByteMiddle).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(0) as *mut u64;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xffffffff00000000u64);
            }
            Ok(())
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<u32>, T1: fidl::encoding::Encode<u64>>
        fidl::encoding::Encode<Padding4ByteMiddle> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding4ByteMiddle>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                    (ptr as *mut u64).write_unaligned(0);
                },
                fidl::encoding::WireFormatVersion::V2 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                    (ptr as *mut u64).write_unaligned(0);
                },
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding4ByteMiddle {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { a: fidl::new_empty!(u32), b: fidl::new_empty!(u64) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let maskedval = padval & 0xffffffff00000000u64;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 0
                        + ((0xffffffff00000000u64 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Padding5ByteEnd {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 16,
                fidl::encoding::WireFormatVersion::V2 => 16,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding5ByteEnd {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding5ByteEnd> for &Padding5ByteEnd {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding5ByteEnd>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding5ByteEnd)
                    .write_unaligned((self as *const Padding5ByteEnd).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(8) as *mut u64;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xffffffffff000000u64);
            }
            Ok(())
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u64>,
            T1: fidl::encoding::Encode<u16>,
            T2: fidl::encoding::Encode<u8>,
        > fidl::encoding::Encode<Padding5ByteEnd> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding5ByteEnd>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                    (ptr as *mut u64).write_unaligned(0);
                },
                fidl::encoding::WireFormatVersion::V2 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                    (ptr as *mut u64).write_unaligned(0);
                },
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 10,
                fidl::encoding::WireFormatVersion::V2 => 10,
            };
            self.2.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding5ByteEnd {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { a: fidl::new_empty!(u64), b: fidl::new_empty!(u16), c: fidl::new_empty!(u8) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let maskedval = padval & 0xffffffffff000000u64;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 8
                        + ((0xffffffffff000000u64 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Padding5ByteMiddle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 16,
                fidl::encoding::WireFormatVersion::V2 => 16,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding5ByteMiddle {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding5ByteMiddle> for &Padding5ByteMiddle {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding5ByteMiddle>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding5ByteMiddle)
                    .write_unaligned((self as *const Padding5ByteMiddle).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(0) as *mut u64;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xffffffffff000000u64);
            }
            Ok(())
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u16>,
            T1: fidl::encoding::Encode<u8>,
            T2: fidl::encoding::Encode<u64>,
        > fidl::encoding::Encode<Padding5ByteMiddle> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding5ByteMiddle>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                    (ptr as *mut u64).write_unaligned(0);
                },
                fidl::encoding::WireFormatVersion::V2 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                    (ptr as *mut u64).write_unaligned(0);
                },
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 2,
                fidl::encoding::WireFormatVersion::V2 => 2,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            };
            self.2.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding5ByteMiddle {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { a: fidl::new_empty!(u16), b: fidl::new_empty!(u8), c: fidl::new_empty!(u64) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let maskedval = padval & 0xffffffffff000000u64;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 0
                        + ((0xffffffffff000000u64 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Padding6ByteEnd {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 16,
                fidl::encoding::WireFormatVersion::V2 => 16,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding6ByteEnd {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding6ByteEnd> for &Padding6ByteEnd {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding6ByteEnd>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding6ByteEnd)
                    .write_unaligned((self as *const Padding6ByteEnd).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(8) as *mut u64;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xffffffffffff0000u64);
            }
            Ok(())
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<u64>, T1: fidl::encoding::Encode<u16>>
        fidl::encoding::Encode<Padding6ByteEnd> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding6ByteEnd>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                    (ptr as *mut u64).write_unaligned(0);
                },
                fidl::encoding::WireFormatVersion::V2 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                    (ptr as *mut u64).write_unaligned(0);
                },
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding6ByteEnd {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { a: fidl::new_empty!(u64), b: fidl::new_empty!(u16) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let maskedval = padval & 0xffffffffffff0000u64;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 8
                        + ((0xffffffffffff0000u64 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Padding6ByteMiddle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 16,
                fidl::encoding::WireFormatVersion::V2 => 16,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding6ByteMiddle {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding6ByteMiddle> for &Padding6ByteMiddle {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding6ByteMiddle>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding6ByteMiddle)
                    .write_unaligned((self as *const Padding6ByteMiddle).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(0) as *mut u64;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xffffffffffff0000u64);
            }
            Ok(())
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<u16>, T1: fidl::encoding::Encode<u64>>
        fidl::encoding::Encode<Padding6ByteMiddle> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding6ByteMiddle>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                    (ptr as *mut u64).write_unaligned(0);
                },
                fidl::encoding::WireFormatVersion::V2 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                    (ptr as *mut u64).write_unaligned(0);
                },
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding6ByteMiddle {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { a: fidl::new_empty!(u16), b: fidl::new_empty!(u64) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let maskedval = padval & 0xffffffffffff0000u64;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 0
                        + ((0xffffffffffff0000u64 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Padding7ByteEnd {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 16,
                fidl::encoding::WireFormatVersion::V2 => 16,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding7ByteEnd {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding7ByteEnd> for &Padding7ByteEnd {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding7ByteEnd>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding7ByteEnd)
                    .write_unaligned((self as *const Padding7ByteEnd).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(8) as *mut u64;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xffffffffffffff00u64);
            }
            Ok(())
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<u64>, T1: fidl::encoding::Encode<u8>>
        fidl::encoding::Encode<Padding7ByteEnd> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding7ByteEnd>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                    (ptr as *mut u64).write_unaligned(0);
                },
                fidl::encoding::WireFormatVersion::V2 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                    (ptr as *mut u64).write_unaligned(0);
                },
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding7ByteEnd {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { a: fidl::new_empty!(u64), b: fidl::new_empty!(u8) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let maskedval = padval & 0xffffffffffffff00u64;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 8
                        + ((0xffffffffffffff00u64 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Padding7ByteMiddle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            }
        }

        #[inline(always)]
        fn inline_size(context: fidl::encoding::Context) -> usize {
            match context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 16,
                fidl::encoding::WireFormatVersion::V2 => 16,
            }
        }
    }
    impl fidl::encoding::ValueTypeMarker for Padding7ByteMiddle {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<Padding7ByteMiddle> for &Padding7ByteMiddle {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding7ByteMiddle>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Padding7ByteMiddle)
                    .write_unaligned((self as *const Padding7ByteMiddle).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(0) as *mut u64;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !0xffffffffffffff00u64);
            }
            Ok(())
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<u8>, T1: fidl::encoding::Encode<u64>>
        fidl::encoding::Encode<Padding7ByteMiddle> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Padding7ByteMiddle>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                    (ptr as *mut u64).write_unaligned(0);
                },
                fidl::encoding::WireFormatVersion::V2 => unsafe {
                    let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                    (ptr as *mut u64).write_unaligned(0);
                },
            };
            // Write the fields.
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 0,
                fidl::encoding::WireFormatVersion::V2 => 0,
            };
            self.0.encode(encoder, offset + member_offset, depth)?;
            let member_offset = match encoder.context.wire_format_version {
                fidl::encoding::WireFormatVersion::V1 => 8,
                fidl::encoding::WireFormatVersion::V2 => 8,
            };
            self.1.encode(encoder, offset + member_offset, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for Padding7ByteMiddle {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { a: fidl::new_empty!(u8), b: fidl::new_empty!(u64) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let maskedval = padval & 0xffffffffffffff00u64;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 0
                        + ((0xffffffffffffff00u64 as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
            }
            Ok(())
        }
    }
}