/*
    automatically generated by rust-bindgen with:
    bindgen.exe --whitelist-function=GetAdaptersAddresses wrapper.h -- --target=i686-pc-windows-msvc
*/

pub type wchar_t = ::std::os::raw::c_ushort;
pub type ULONG = ::std::os::raw::c_ulong;
pub type PULONG = *mut ULONG;
pub type USHORT = ::std::os::raw::c_ushort;
pub type DWORD = ::std::os::raw::c_ulong;
pub type BYTE = ::std::os::raw::c_uchar;
pub type INT = ::std::os::raw::c_int;
pub type UINT8 = ::std::os::raw::c_uchar;
pub type UINT32 = ::std::os::raw::c_uint;
pub type ULONG64 = ::std::os::raw::c_ulonglong;
pub type PVOID = *mut ::std::os::raw::c_void;
pub type CHAR = ::std::os::raw::c_char;
pub type WCHAR = wchar_t;
pub type PWCHAR = *mut WCHAR;
pub type PCHAR = *mut CHAR;
pub type ULONGLONG = ::std::os::raw::c_ulonglong;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct _GUID {
    pub Data1: ::std::os::raw::c_ulong,
    pub Data2: ::std::os::raw::c_ushort,
    pub Data3: ::std::os::raw::c_ushort,
    pub Data4: [::std::os::raw::c_uchar; 8usize],
}
#[test]
fn bindgen_test_layout__GUID() {
    assert_eq!(
        ::std::mem::size_of::<_GUID>(),
        16usize,
        concat!("Size of: ", stringify!(_GUID))
    );
    assert_eq!(
        ::std::mem::align_of::<_GUID>(),
        4usize,
        concat!("Alignment of ", stringify!(_GUID))
    );
    assert_eq!(
        unsafe { &(*(0 as *const _GUID)).Data1 as *const _ as usize },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_GUID),
            "::",
            stringify!(Data1)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _GUID)).Data2 as *const _ as usize },
        4usize,
        concat!(
            "Alignment of field: ",
            stringify!(_GUID),
            "::",
            stringify!(Data2)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _GUID)).Data3 as *const _ as usize },
        6usize,
        concat!(
            "Alignment of field: ",
            stringify!(_GUID),
            "::",
            stringify!(Data3)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _GUID)).Data4 as *const _ as usize },
        8usize,
        concat!(
            "Alignment of field: ",
            stringify!(_GUID),
            "::",
            stringify!(Data4)
        )
    );
}
impl Clone for _GUID {
    fn clone(&self) -> Self {
        *self
    }
}
pub type GUID = _GUID;
pub type ADDRESS_FAMILY = USHORT;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct sockaddr {
    pub sa_family: ADDRESS_FAMILY,
    pub sa_data: [CHAR; 14usize],
}
#[test]
fn bindgen_test_layout_sockaddr() {
    assert_eq!(
        ::std::mem::size_of::<sockaddr>(),
        16usize,
        concat!("Size of: ", stringify!(sockaddr))
    );
    assert_eq!(
        ::std::mem::align_of::<sockaddr>(),
        2usize,
        concat!("Alignment of ", stringify!(sockaddr))
    );
    assert_eq!(
        unsafe { &(*(0 as *const sockaddr)).sa_family as *const _ as usize },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(sockaddr),
            "::",
            stringify!(sa_family)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const sockaddr)).sa_data as *const _ as usize },
        2usize,
        concat!(
            "Alignment of field: ",
            stringify!(sockaddr),
            "::",
            stringify!(sa_data)
        )
    );
}
impl Clone for sockaddr {
    fn clone(&self) -> Self {
        *self
    }
}
pub type LPSOCKADDR = *mut sockaddr;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct _SOCKET_ADDRESS {
    pub lpSockaddr: LPSOCKADDR,
    pub iSockaddrLength: INT,
}
#[test]
fn bindgen_test_layout__SOCKET_ADDRESS() {
    assert_eq!(
        ::std::mem::size_of::<_SOCKET_ADDRESS>(),
        8usize,
        concat!("Size of: ", stringify!(_SOCKET_ADDRESS))
    );
    assert_eq!(
        ::std::mem::align_of::<_SOCKET_ADDRESS>(),
        4usize,
        concat!("Alignment of ", stringify!(_SOCKET_ADDRESS))
    );
    assert_eq!(
        unsafe { &(*(0 as *const _SOCKET_ADDRESS)).lpSockaddr as *const _ as usize },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_SOCKET_ADDRESS),
            "::",
            stringify!(lpSockaddr)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _SOCKET_ADDRESS)).iSockaddrLength as *const _ as usize },
        4usize,
        concat!(
            "Alignment of field: ",
            stringify!(_SOCKET_ADDRESS),
            "::",
            stringify!(iSockaddrLength)
        )
    );
}
impl Clone for _SOCKET_ADDRESS {
    fn clone(&self) -> Self {
        *self
    }
}
pub type SOCKET_ADDRESS = _SOCKET_ADDRESS;
pub type IFTYPE = ULONG;
pub type NET_IF_COMPARTMENT_ID = UINT32;
pub type NET_IF_NETWORK_GUID = GUID;
#[repr(C)]
#[derive(Copy)]
pub union _NET_LUID_LH {
    pub Value: ULONG64,
    pub Info: _NET_LUID_LH__bindgen_ty_1,
    _bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct _NET_LUID_LH__bindgen_ty_1 {
    pub _bitfield_1: [u32; 2usize],
    pub __bindgen_align: [u64; 0usize],
}
#[test]
fn bindgen_test_layout__NET_LUID_LH__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_NET_LUID_LH__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(_NET_LUID_LH__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<_NET_LUID_LH__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(_NET_LUID_LH__bindgen_ty_1))
    );
}
impl Clone for _NET_LUID_LH__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
impl _NET_LUID_LH__bindgen_ty_1 {
    #[inline]
    pub fn Reserved(&self) -> ULONG64 {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u64 as *mut u8,
                ::std::mem::size_of::<u64>(),
            )
        };
        let mask = 0xffffff as u64;
        let val = (unit_field_val & mask) >> 0usize;
        unsafe { ::std::mem::transmute(val as u64) }
    }
    #[inline]
    pub fn set_Reserved(&mut self, val: ULONG64) {
        let mask = 0xffffff as u64;
        let val = val as u64 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u64 as *mut u8,
                ::std::mem::size_of::<u64>(),
            )
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 0usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &unit_field_val as *const _ as *const u8,
                &mut self._bitfield_1 as *mut _ as *mut u8,
                ::std::mem::size_of::<u64>(),
            );
        }
    }
    #[inline]
    pub fn NetLuidIndex(&self) -> ULONG64 {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u64 as *mut u8,
                ::std::mem::size_of::<u64>(),
            )
        };
        let mask = 0xffffff000000 as u64;
        let val = (unit_field_val & mask) >> 24usize;
        unsafe { ::std::mem::transmute(val as u64) }
    }
    #[inline]
    pub fn set_NetLuidIndex(&mut self, val: ULONG64) {
        let mask = 0xffffff000000 as u64;
        let val = val as u64 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u64 as *mut u8,
                ::std::mem::size_of::<u64>(),
            )
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 24usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &unit_field_val as *const _ as *const u8,
                &mut self._bitfield_1 as *mut _ as *mut u8,
                ::std::mem::size_of::<u64>(),
            );
        }
    }
    #[inline]
    pub fn IfType(&self) -> ULONG64 {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u64 as *mut u8,
                ::std::mem::size_of::<u64>(),
            )
        };
        let mask = 0xffff000000000000 as u64;
        let val = (unit_field_val & mask) >> 48usize;
        unsafe { ::std::mem::transmute(val as u64) }
    }
    #[inline]
    pub fn set_IfType(&mut self, val: ULONG64) {
        let mask = 0xffff000000000000 as u64;
        let val = val as u64 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u64 as *mut u8,
                ::std::mem::size_of::<u64>(),
            )
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 48usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &unit_field_val as *const _ as *const u8,
                &mut self._bitfield_1 as *mut _ as *mut u8,
                ::std::mem::size_of::<u64>(),
            );
        }
    }
    #[inline]
    pub fn new_bitfield_1(Reserved: ULONG64, NetLuidIndex: ULONG64, IfType: ULONG64) -> u64 {
        (((0 | ((Reserved as u64 as u64) << 0usize) & (0xffffff as u64))
            | ((NetLuidIndex as u64 as u64) << 24usize) & (0xffffff000000 as u64))
            | ((IfType as u64 as u64) << 48usize) & (0xffff000000000000 as u64))
    }
}
#[test]
fn bindgen_test_layout__NET_LUID_LH() {
    assert_eq!(
        ::std::mem::size_of::<_NET_LUID_LH>(),
        8usize,
        concat!("Size of: ", stringify!(_NET_LUID_LH))
    );
    assert_eq!(
        ::std::mem::align_of::<_NET_LUID_LH>(),
        8usize,
        concat!("Alignment of ", stringify!(_NET_LUID_LH))
    );
    assert_eq!(
        unsafe { &(*(0 as *const _NET_LUID_LH)).Value as *const _ as usize },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_NET_LUID_LH),
            "::",
            stringify!(Value)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _NET_LUID_LH)).Info as *const _ as usize },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_NET_LUID_LH),
            "::",
            stringify!(Info)
        )
    );
}
impl Clone for _NET_LUID_LH {
    fn clone(&self) -> Self {
        *self
    }
}
pub type NET_LUID_LH = _NET_LUID_LH;
pub type NET_LUID = NET_LUID_LH;
pub type IF_LUID = NET_LUID;
pub type NET_IFINDEX = ULONG;
pub type IF_INDEX = NET_IFINDEX;
pub const _NET_IF_CONNECTION_TYPE_NET_IF_CONNECTION_DEDICATED: _NET_IF_CONNECTION_TYPE = 1;
pub const _NET_IF_CONNECTION_TYPE_NET_IF_CONNECTION_PASSIVE: _NET_IF_CONNECTION_TYPE = 2;
pub const _NET_IF_CONNECTION_TYPE_NET_IF_CONNECTION_DEMAND: _NET_IF_CONNECTION_TYPE = 3;
pub const _NET_IF_CONNECTION_TYPE_NET_IF_CONNECTION_MAXIMUM: _NET_IF_CONNECTION_TYPE = 4;
pub type _NET_IF_CONNECTION_TYPE = ::std::os::raw::c_int;
pub use self::_NET_IF_CONNECTION_TYPE as NET_IF_CONNECTION_TYPE;
pub const TUNNEL_TYPE_TUNNEL_TYPE_NONE: TUNNEL_TYPE = 0;
pub const TUNNEL_TYPE_TUNNEL_TYPE_OTHER: TUNNEL_TYPE = 1;
pub const TUNNEL_TYPE_TUNNEL_TYPE_DIRECT: TUNNEL_TYPE = 2;
pub const TUNNEL_TYPE_TUNNEL_TYPE_6TO4: TUNNEL_TYPE = 11;
pub const TUNNEL_TYPE_TUNNEL_TYPE_ISATAP: TUNNEL_TYPE = 13;
pub const TUNNEL_TYPE_TUNNEL_TYPE_TEREDO: TUNNEL_TYPE = 14;
pub const TUNNEL_TYPE_TUNNEL_TYPE_IPHTTPS: TUNNEL_TYPE = 15;
pub type TUNNEL_TYPE = ::std::os::raw::c_int;
pub const IF_OPER_STATUS_IfOperStatusUp: IF_OPER_STATUS = 1;
pub const IF_OPER_STATUS_IfOperStatusDown: IF_OPER_STATUS = 2;
pub const IF_OPER_STATUS_IfOperStatusTesting: IF_OPER_STATUS = 3;
pub const IF_OPER_STATUS_IfOperStatusUnknown: IF_OPER_STATUS = 4;
pub const IF_OPER_STATUS_IfOperStatusDormant: IF_OPER_STATUS = 5;
pub const IF_OPER_STATUS_IfOperStatusNotPresent: IF_OPER_STATUS = 6;
pub const IF_OPER_STATUS_IfOperStatusLowerLayerDown: IF_OPER_STATUS = 7;
pub type IF_OPER_STATUS = ::std::os::raw::c_int;
pub const NL_PREFIX_ORIGIN_IpPrefixOriginOther: NL_PREFIX_ORIGIN = 0;
pub const NL_PREFIX_ORIGIN_IpPrefixOriginManual: NL_PREFIX_ORIGIN = 1;
pub const NL_PREFIX_ORIGIN_IpPrefixOriginWellKnown: NL_PREFIX_ORIGIN = 2;
pub const NL_PREFIX_ORIGIN_IpPrefixOriginDhcp: NL_PREFIX_ORIGIN = 3;
pub const NL_PREFIX_ORIGIN_IpPrefixOriginRouterAdvertisement: NL_PREFIX_ORIGIN = 4;
pub const NL_PREFIX_ORIGIN_IpPrefixOriginUnchanged: NL_PREFIX_ORIGIN = 16;
pub type NL_PREFIX_ORIGIN = ::std::os::raw::c_int;
pub const NL_SUFFIX_ORIGIN_NlsoOther: NL_SUFFIX_ORIGIN = 0;
pub const NL_SUFFIX_ORIGIN_NlsoManual: NL_SUFFIX_ORIGIN = 1;
pub const NL_SUFFIX_ORIGIN_NlsoWellKnown: NL_SUFFIX_ORIGIN = 2;
pub const NL_SUFFIX_ORIGIN_NlsoDhcp: NL_SUFFIX_ORIGIN = 3;
pub const NL_SUFFIX_ORIGIN_NlsoLinkLayerAddress: NL_SUFFIX_ORIGIN = 4;
pub const NL_SUFFIX_ORIGIN_NlsoRandom: NL_SUFFIX_ORIGIN = 5;
pub const NL_SUFFIX_ORIGIN_IpSuffixOriginOther: NL_SUFFIX_ORIGIN = 0;
pub const NL_SUFFIX_ORIGIN_IpSuffixOriginManual: NL_SUFFIX_ORIGIN = 1;
pub const NL_SUFFIX_ORIGIN_IpSuffixOriginWellKnown: NL_SUFFIX_ORIGIN = 2;
pub const NL_SUFFIX_ORIGIN_IpSuffixOriginDhcp: NL_SUFFIX_ORIGIN = 3;
pub const NL_SUFFIX_ORIGIN_IpSuffixOriginLinkLayerAddress: NL_SUFFIX_ORIGIN = 4;
pub const NL_SUFFIX_ORIGIN_IpSuffixOriginRandom: NL_SUFFIX_ORIGIN = 5;
pub const NL_SUFFIX_ORIGIN_IpSuffixOriginUnchanged: NL_SUFFIX_ORIGIN = 16;
pub type NL_SUFFIX_ORIGIN = ::std::os::raw::c_int;
pub const NL_DAD_STATE_NldsInvalid: NL_DAD_STATE = 0;
pub const NL_DAD_STATE_NldsTentative: NL_DAD_STATE = 1;
pub const NL_DAD_STATE_NldsDuplicate: NL_DAD_STATE = 2;
pub const NL_DAD_STATE_NldsDeprecated: NL_DAD_STATE = 3;
pub const NL_DAD_STATE_NldsPreferred: NL_DAD_STATE = 4;
pub const NL_DAD_STATE_IpDadStateInvalid: NL_DAD_STATE = 0;
pub const NL_DAD_STATE_IpDadStateTentative: NL_DAD_STATE = 1;
pub const NL_DAD_STATE_IpDadStateDuplicate: NL_DAD_STATE = 2;
pub const NL_DAD_STATE_IpDadStateDeprecated: NL_DAD_STATE = 3;
pub const NL_DAD_STATE_IpDadStatePreferred: NL_DAD_STATE = 4;
pub type NL_DAD_STATE = ::std::os::raw::c_int;
pub use self::NL_DAD_STATE as IP_DAD_STATE;
pub use self::NL_PREFIX_ORIGIN as IP_PREFIX_ORIGIN;
pub use self::NL_SUFFIX_ORIGIN as IP_SUFFIX_ORIGIN;
#[repr(C)]
#[derive(Copy)]
pub struct _IP_ADAPTER_UNICAST_ADDRESS_LH {
    pub __bindgen_anon_1: _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1,
    pub Next: *mut _IP_ADAPTER_UNICAST_ADDRESS_LH,
    pub Address: SOCKET_ADDRESS,
    pub PrefixOrigin: IP_PREFIX_ORIGIN,
    pub SuffixOrigin: IP_SUFFIX_ORIGIN,
    pub DadState: IP_DAD_STATE,
    pub ValidLifetime: ULONG,
    pub PreferredLifetime: ULONG,
    pub LeaseLifetime: ULONG,
    pub OnLinkPrefixLength: UINT8,
}
#[repr(C)]
#[derive(Copy)]
pub union _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1 {
    pub Alignment: ULONGLONG,
    pub __bindgen_anon_1: _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
    _bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1 {
    pub Length: ULONG,
    pub Flags: DWORD,
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1)).Length
                as *const _ as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(Length)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1)).Flags
                as *const _ as usize
        },
        4usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(Flags)
        )
    );
}
impl Clone for _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1)).Alignment as *const _
                as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1),
            "::",
            stringify!(Alignment)
        )
    );
}
impl Clone for _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_UNICAST_ADDRESS_LH() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_UNICAST_ADDRESS_LH>(),
        48usize,
        concat!("Size of: ", stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH))
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_UNICAST_ADDRESS_LH>(),
        8usize,
        concat!("Alignment of ", stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH))
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_UNICAST_ADDRESS_LH)).Next as *const _ as usize },
        8usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH),
            "::",
            stringify!(Next)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_UNICAST_ADDRESS_LH)).Address as *const _ as usize },
        12usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH),
            "::",
            stringify!(Address)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_UNICAST_ADDRESS_LH)).PrefixOrigin as *const _ as usize
        },
        20usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH),
            "::",
            stringify!(PrefixOrigin)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_UNICAST_ADDRESS_LH)).SuffixOrigin as *const _ as usize
        },
        24usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH),
            "::",
            stringify!(SuffixOrigin)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_UNICAST_ADDRESS_LH)).DadState as *const _ as usize },
        28usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH),
            "::",
            stringify!(DadState)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_UNICAST_ADDRESS_LH)).ValidLifetime as *const _ as usize
        },
        32usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH),
            "::",
            stringify!(ValidLifetime)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_UNICAST_ADDRESS_LH)).PreferredLifetime as *const _ as usize
        },
        36usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH),
            "::",
            stringify!(PreferredLifetime)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_UNICAST_ADDRESS_LH)).LeaseLifetime as *const _ as usize
        },
        40usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH),
            "::",
            stringify!(LeaseLifetime)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_UNICAST_ADDRESS_LH)).OnLinkPrefixLength as *const _ as usize
        },
        44usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_UNICAST_ADDRESS_LH),
            "::",
            stringify!(OnLinkPrefixLength)
        )
    );
}
impl Clone for _IP_ADAPTER_UNICAST_ADDRESS_LH {
    fn clone(&self) -> Self {
        *self
    }
}
pub type PIP_ADAPTER_UNICAST_ADDRESS_LH = *mut _IP_ADAPTER_UNICAST_ADDRESS_LH;
#[repr(C)]
#[derive(Copy)]
pub struct _IP_ADAPTER_ANYCAST_ADDRESS_XP {
    pub __bindgen_anon_1: _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1,
    pub Next: *mut _IP_ADAPTER_ANYCAST_ADDRESS_XP,
    pub Address: SOCKET_ADDRESS,
}
#[repr(C)]
#[derive(Copy)]
pub union _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1 {
    pub Alignment: ULONGLONG,
    pub __bindgen_anon_1: _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
    _bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1 {
    pub Length: ULONG,
    pub Flags: DWORD,
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1)).Length
                as *const _ as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(Length)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1)).Flags
                as *const _ as usize
        },
        4usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(Flags)
        )
    );
}
impl Clone for _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1)).Alignment as *const _
                as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1),
            "::",
            stringify!(Alignment)
        )
    );
}
impl Clone for _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_ANYCAST_ADDRESS_XP() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_ANYCAST_ADDRESS_XP>(),
        24usize,
        concat!("Size of: ", stringify!(_IP_ADAPTER_ANYCAST_ADDRESS_XP))
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_ANYCAST_ADDRESS_XP>(),
        8usize,
        concat!("Alignment of ", stringify!(_IP_ADAPTER_ANYCAST_ADDRESS_XP))
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ANYCAST_ADDRESS_XP)).Next as *const _ as usize },
        8usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ANYCAST_ADDRESS_XP),
            "::",
            stringify!(Next)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ANYCAST_ADDRESS_XP)).Address as *const _ as usize },
        12usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ANYCAST_ADDRESS_XP),
            "::",
            stringify!(Address)
        )
    );
}
impl Clone for _IP_ADAPTER_ANYCAST_ADDRESS_XP {
    fn clone(&self) -> Self {
        *self
    }
}
pub type PIP_ADAPTER_ANYCAST_ADDRESS_XP = *mut _IP_ADAPTER_ANYCAST_ADDRESS_XP;
#[repr(C)]
#[derive(Copy)]
pub struct _IP_ADAPTER_MULTICAST_ADDRESS_XP {
    pub __bindgen_anon_1: _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1,
    pub Next: *mut _IP_ADAPTER_MULTICAST_ADDRESS_XP,
    pub Address: SOCKET_ADDRESS,
}
#[repr(C)]
#[derive(Copy)]
pub union _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1 {
    pub Alignment: ULONGLONG,
    pub __bindgen_anon_1: _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
    _bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1 {
    pub Length: ULONG,
    pub Flags: DWORD,
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1)).Length
                as *const _ as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(Length)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1)).Flags
                as *const _ as usize
        },
        4usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(Flags)
        )
    );
}
impl Clone for _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1)).Alignment as *const _
                as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1),
            "::",
            stringify!(Alignment)
        )
    );
}
impl Clone for _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_MULTICAST_ADDRESS_XP() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_MULTICAST_ADDRESS_XP>(),
        24usize,
        concat!("Size of: ", stringify!(_IP_ADAPTER_MULTICAST_ADDRESS_XP))
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_MULTICAST_ADDRESS_XP>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_MULTICAST_ADDRESS_XP)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_MULTICAST_ADDRESS_XP)).Next as *const _ as usize },
        8usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_MULTICAST_ADDRESS_XP),
            "::",
            stringify!(Next)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_MULTICAST_ADDRESS_XP)).Address as *const _ as usize },
        12usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_MULTICAST_ADDRESS_XP),
            "::",
            stringify!(Address)
        )
    );
}
impl Clone for _IP_ADAPTER_MULTICAST_ADDRESS_XP {
    fn clone(&self) -> Self {
        *self
    }
}
pub type PIP_ADAPTER_MULTICAST_ADDRESS_XP = *mut _IP_ADAPTER_MULTICAST_ADDRESS_XP;
#[repr(C)]
#[derive(Copy)]
pub struct _IP_ADAPTER_DNS_SERVER_ADDRESS_XP {
    pub __bindgen_anon_1: _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1,
    pub Next: *mut _IP_ADAPTER_DNS_SERVER_ADDRESS_XP,
    pub Address: SOCKET_ADDRESS,
}
#[repr(C)]
#[derive(Copy)]
pub union _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1 {
    pub Alignment: ULONGLONG,
    pub __bindgen_anon_1: _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
    _bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1 {
    pub Length: ULONG,
    pub Reserved: DWORD,
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1)).Length
                as *const _ as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(Length)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1)).Reserved
                as *const _ as usize
        },
        4usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(Reserved)
        )
    );
}
impl Clone for _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1)).Alignment as *const _
                as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1),
            "::",
            stringify!(Alignment)
        )
    );
}
impl Clone for _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_DNS_SERVER_ADDRESS_XP() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_DNS_SERVER_ADDRESS_XP>(),
        24usize,
        concat!("Size of: ", stringify!(_IP_ADAPTER_DNS_SERVER_ADDRESS_XP))
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_DNS_SERVER_ADDRESS_XP>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_DNS_SERVER_ADDRESS_XP)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_DNS_SERVER_ADDRESS_XP)).Next as *const _ as usize },
        8usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_DNS_SERVER_ADDRESS_XP),
            "::",
            stringify!(Next)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_DNS_SERVER_ADDRESS_XP)).Address as *const _ as usize },
        12usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_DNS_SERVER_ADDRESS_XP),
            "::",
            stringify!(Address)
        )
    );
}
impl Clone for _IP_ADAPTER_DNS_SERVER_ADDRESS_XP {
    fn clone(&self) -> Self {
        *self
    }
}
pub type PIP_ADAPTER_DNS_SERVER_ADDRESS_XP = *mut _IP_ADAPTER_DNS_SERVER_ADDRESS_XP;
#[repr(C)]
#[derive(Copy)]
pub struct _IP_ADAPTER_WINS_SERVER_ADDRESS_LH {
    pub __bindgen_anon_1: _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1,
    pub Next: *mut _IP_ADAPTER_WINS_SERVER_ADDRESS_LH,
    pub Address: SOCKET_ADDRESS,
}
#[repr(C)]
#[derive(Copy)]
pub union _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1 {
    pub Alignment: ULONGLONG,
    pub __bindgen_anon_1: _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
    _bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1 {
    pub Length: ULONG,
    pub Reserved: DWORD,
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1)).Length
                as *const _ as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(Length)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1))
                .Reserved as *const _ as usize
        },
        4usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(Reserved)
        )
    );
}
impl Clone for _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1)).Alignment as *const _
                as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1),
            "::",
            stringify!(Alignment)
        )
    );
}
impl Clone for _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_WINS_SERVER_ADDRESS_LH() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_WINS_SERVER_ADDRESS_LH>(),
        24usize,
        concat!("Size of: ", stringify!(_IP_ADAPTER_WINS_SERVER_ADDRESS_LH))
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_WINS_SERVER_ADDRESS_LH>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_WINS_SERVER_ADDRESS_LH)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_WINS_SERVER_ADDRESS_LH)).Next as *const _ as usize },
        8usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_WINS_SERVER_ADDRESS_LH),
            "::",
            stringify!(Next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_WINS_SERVER_ADDRESS_LH)).Address as *const _ as usize
        },
        12usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_WINS_SERVER_ADDRESS_LH),
            "::",
            stringify!(Address)
        )
    );
}
impl Clone for _IP_ADAPTER_WINS_SERVER_ADDRESS_LH {
    fn clone(&self) -> Self {
        *self
    }
}
pub type PIP_ADAPTER_WINS_SERVER_ADDRESS_LH = *mut _IP_ADAPTER_WINS_SERVER_ADDRESS_LH;
#[repr(C)]
#[derive(Copy)]
pub struct _IP_ADAPTER_GATEWAY_ADDRESS_LH {
    pub __bindgen_anon_1: _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1,
    pub Next: *mut _IP_ADAPTER_GATEWAY_ADDRESS_LH,
    pub Address: SOCKET_ADDRESS,
}
#[repr(C)]
#[derive(Copy)]
pub union _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1 {
    pub Alignment: ULONGLONG,
    pub __bindgen_anon_1: _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
    _bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1 {
    pub Length: ULONG,
    pub Reserved: DWORD,
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1)).Length
                as *const _ as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(Length)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1)).Reserved
                as *const _ as usize
        },
        4usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(Reserved)
        )
    );
}
impl Clone for _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1)).Alignment as *const _
                as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1),
            "::",
            stringify!(Alignment)
        )
    );
}
impl Clone for _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_GATEWAY_ADDRESS_LH() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_GATEWAY_ADDRESS_LH>(),
        24usize,
        concat!("Size of: ", stringify!(_IP_ADAPTER_GATEWAY_ADDRESS_LH))
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_GATEWAY_ADDRESS_LH>(),
        8usize,
        concat!("Alignment of ", stringify!(_IP_ADAPTER_GATEWAY_ADDRESS_LH))
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_GATEWAY_ADDRESS_LH)).Next as *const _ as usize },
        8usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_GATEWAY_ADDRESS_LH),
            "::",
            stringify!(Next)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_GATEWAY_ADDRESS_LH)).Address as *const _ as usize },
        12usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_GATEWAY_ADDRESS_LH),
            "::",
            stringify!(Address)
        )
    );
}
impl Clone for _IP_ADAPTER_GATEWAY_ADDRESS_LH {
    fn clone(&self) -> Self {
        *self
    }
}
pub type PIP_ADAPTER_GATEWAY_ADDRESS_LH = *mut _IP_ADAPTER_GATEWAY_ADDRESS_LH;
#[repr(C)]
#[derive(Copy)]
pub struct _IP_ADAPTER_PREFIX_XP {
    pub __bindgen_anon_1: _IP_ADAPTER_PREFIX_XP__bindgen_ty_1,
    pub Next: *mut _IP_ADAPTER_PREFIX_XP,
    pub Address: SOCKET_ADDRESS,
    pub PrefixLength: ULONG,
}
#[repr(C)]
#[derive(Copy)]
pub union _IP_ADAPTER_PREFIX_XP__bindgen_ty_1 {
    pub Alignment: ULONGLONG,
    pub __bindgen_anon_1: _IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1,
    _bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct _IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1 {
    pub Length: ULONG,
    pub Flags: DWORD,
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1)).Length as *const _
                as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(Length)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1)).Flags as *const _
                as usize
        },
        4usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(Flags)
        )
    );
}
impl Clone for _IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_PREFIX_XP__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_PREFIX_XP__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(_IP_ADAPTER_PREFIX_XP__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_PREFIX_XP__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_PREFIX_XP__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_PREFIX_XP__bindgen_ty_1)).Alignment as *const _ as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_PREFIX_XP__bindgen_ty_1),
            "::",
            stringify!(Alignment)
        )
    );
}
impl Clone for _IP_ADAPTER_PREFIX_XP__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_PREFIX_XP() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_PREFIX_XP>(),
        24usize,
        concat!("Size of: ", stringify!(_IP_ADAPTER_PREFIX_XP))
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_PREFIX_XP>(),
        8usize,
        concat!("Alignment of ", stringify!(_IP_ADAPTER_PREFIX_XP))
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_PREFIX_XP)).Next as *const _ as usize },
        8usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_PREFIX_XP),
            "::",
            stringify!(Next)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_PREFIX_XP)).Address as *const _ as usize },
        12usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_PREFIX_XP),
            "::",
            stringify!(Address)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_PREFIX_XP)).PrefixLength as *const _ as usize },
        20usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_PREFIX_XP),
            "::",
            stringify!(PrefixLength)
        )
    );
}
impl Clone for _IP_ADAPTER_PREFIX_XP {
    fn clone(&self) -> Self {
        *self
    }
}
pub type PIP_ADAPTER_PREFIX_XP = *mut _IP_ADAPTER_PREFIX_XP;
#[repr(C)]
#[derive(Copy)]
pub struct _IP_ADAPTER_DNS_SUFFIX {
    pub Next: *mut _IP_ADAPTER_DNS_SUFFIX,
    pub String: [WCHAR; 256usize],
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_DNS_SUFFIX() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_DNS_SUFFIX>(),
        516usize,
        concat!("Size of: ", stringify!(_IP_ADAPTER_DNS_SUFFIX))
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_DNS_SUFFIX>(),
        4usize,
        concat!("Alignment of ", stringify!(_IP_ADAPTER_DNS_SUFFIX))
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_DNS_SUFFIX)).Next as *const _ as usize },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_DNS_SUFFIX),
            "::",
            stringify!(Next)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_DNS_SUFFIX)).String as *const _ as usize },
        4usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_DNS_SUFFIX),
            "::",
            stringify!(String)
        )
    );
}
impl Clone for _IP_ADAPTER_DNS_SUFFIX {
    fn clone(&self) -> Self {
        *self
    }
}
pub type PIP_ADAPTER_DNS_SUFFIX = *mut _IP_ADAPTER_DNS_SUFFIX;
#[repr(C)]
#[derive(Copy)]
pub struct _IP_ADAPTER_ADDRESSES_LH {
    pub __bindgen_anon_1: _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1,
    pub Next: *mut _IP_ADAPTER_ADDRESSES_LH,
    pub AdapterName: PCHAR,
    pub FirstUnicastAddress: PIP_ADAPTER_UNICAST_ADDRESS_LH,
    pub FirstAnycastAddress: PIP_ADAPTER_ANYCAST_ADDRESS_XP,
    pub FirstMulticastAddress: PIP_ADAPTER_MULTICAST_ADDRESS_XP,
    pub FirstDnsServerAddress: PIP_ADAPTER_DNS_SERVER_ADDRESS_XP,
    pub DnsSuffix: PWCHAR,
    pub Description: PWCHAR,
    pub FriendlyName: PWCHAR,
    pub PhysicalAddress: [BYTE; 8usize],
    pub PhysicalAddressLength: ULONG,
    pub __bindgen_anon_2: _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2,
    pub Mtu: ULONG,
    pub IfType: IFTYPE,
    pub OperStatus: IF_OPER_STATUS,
    pub Ipv6IfIndex: IF_INDEX,
    pub ZoneIndices: [ULONG; 16usize],
    pub FirstPrefix: PIP_ADAPTER_PREFIX_XP,
    pub TransmitLinkSpeed: ULONG64,
    pub ReceiveLinkSpeed: ULONG64,
    pub FirstWinsServerAddress: PIP_ADAPTER_WINS_SERVER_ADDRESS_LH,
    pub FirstGatewayAddress: PIP_ADAPTER_GATEWAY_ADDRESS_LH,
    pub Ipv4Metric: ULONG,
    pub Ipv6Metric: ULONG,
    pub Luid: IF_LUID,
    pub Dhcpv4Server: SOCKET_ADDRESS,
    pub CompartmentId: NET_IF_COMPARTMENT_ID,
    pub NetworkGuid: NET_IF_NETWORK_GUID,
    pub ConnectionType: NET_IF_CONNECTION_TYPE,
    pub TunnelType: TUNNEL_TYPE,
    pub Dhcpv6Server: SOCKET_ADDRESS,
    pub Dhcpv6ClientDuid: [BYTE; 130usize],
    pub Dhcpv6ClientDuidLength: ULONG,
    pub Dhcpv6Iaid: ULONG,
    pub FirstDnsSuffix: PIP_ADAPTER_DNS_SUFFIX,
}
#[repr(C)]
#[derive(Copy)]
pub union _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1 {
    pub Alignment: ULONGLONG,
    pub __bindgen_anon_1: _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1,
    _bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1 {
    pub Length: ULONG,
    pub IfIndex: IF_INDEX,
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1)).Length
                as *const _ as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(Length)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1)).IfIndex
                as *const _ as usize
        },
        4usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(IfIndex)
        )
    );
}
impl Clone for _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1)).Alignment as *const _ as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1),
            "::",
            stringify!(Alignment)
        )
    );
}
impl Clone for _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
#[repr(C)]
#[derive(Copy)]
pub union _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2 {
    pub Flags: ULONG,
    pub __bindgen_anon_1: _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1,
    _bindgen_union_align: u32,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1 {
    pub _bitfield_1: [u8; 2usize],
    pub __bindgen_padding_0: u16,
    pub __bindgen_align: [u32; 0usize],
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1>(),
        4usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1)
        )
    );
}
impl Clone for _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1 {
    fn clone(&self) -> Self {
        *self
    }
}
impl _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1 {
    #[inline]
    pub fn DdnsEnabled(&self) -> ULONG {
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        let mask = 0x1 as u16;
        let val = (unit_field_val & mask) >> 0usize;
        unsafe { ::std::mem::transmute(val as u32) }
    }
    #[inline]
    pub fn set_DdnsEnabled(&mut self, val: ULONG) {
        let mask = 0x1 as u16;
        let val = val as u32 as u16;
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 0usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &unit_field_val as *const _ as *const u8,
                &mut self._bitfield_1 as *mut _ as *mut u8,
                ::std::mem::size_of::<u16>(),
            );
        }
    }
    #[inline]
    pub fn RegisterAdapterSuffix(&self) -> ULONG {
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        let mask = 0x2 as u16;
        let val = (unit_field_val & mask) >> 1usize;
        unsafe { ::std::mem::transmute(val as u32) }
    }
    #[inline]
    pub fn set_RegisterAdapterSuffix(&mut self, val: ULONG) {
        let mask = 0x2 as u16;
        let val = val as u32 as u16;
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 1usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &unit_field_val as *const _ as *const u8,
                &mut self._bitfield_1 as *mut _ as *mut u8,
                ::std::mem::size_of::<u16>(),
            );
        }
    }
    #[inline]
    pub fn Dhcpv4Enabled(&self) -> ULONG {
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        let mask = 0x4 as u16;
        let val = (unit_field_val & mask) >> 2usize;
        unsafe { ::std::mem::transmute(val as u32) }
    }
    #[inline]
    pub fn set_Dhcpv4Enabled(&mut self, val: ULONG) {
        let mask = 0x4 as u16;
        let val = val as u32 as u16;
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 2usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &unit_field_val as *const _ as *const u8,
                &mut self._bitfield_1 as *mut _ as *mut u8,
                ::std::mem::size_of::<u16>(),
            );
        }
    }
    #[inline]
    pub fn ReceiveOnly(&self) -> ULONG {
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        let mask = 0x8 as u16;
        let val = (unit_field_val & mask) >> 3usize;
        unsafe { ::std::mem::transmute(val as u32) }
    }
    #[inline]
    pub fn set_ReceiveOnly(&mut self, val: ULONG) {
        let mask = 0x8 as u16;
        let val = val as u32 as u16;
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 3usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &unit_field_val as *const _ as *const u8,
                &mut self._bitfield_1 as *mut _ as *mut u8,
                ::std::mem::size_of::<u16>(),
            );
        }
    }
    #[inline]
    pub fn NoMulticast(&self) -> ULONG {
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        let mask = 0x10 as u16;
        let val = (unit_field_val & mask) >> 4usize;
        unsafe { ::std::mem::transmute(val as u32) }
    }
    #[inline]
    pub fn set_NoMulticast(&mut self, val: ULONG) {
        let mask = 0x10 as u16;
        let val = val as u32 as u16;
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 4usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &unit_field_val as *const _ as *const u8,
                &mut self._bitfield_1 as *mut _ as *mut u8,
                ::std::mem::size_of::<u16>(),
            );
        }
    }
    #[inline]
    pub fn Ipv6OtherStatefulConfig(&self) -> ULONG {
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        let mask = 0x20 as u16;
        let val = (unit_field_val & mask) >> 5usize;
        unsafe { ::std::mem::transmute(val as u32) }
    }
    #[inline]
    pub fn set_Ipv6OtherStatefulConfig(&mut self, val: ULONG) {
        let mask = 0x20 as u16;
        let val = val as u32 as u16;
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 5usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &unit_field_val as *const _ as *const u8,
                &mut self._bitfield_1 as *mut _ as *mut u8,
                ::std::mem::size_of::<u16>(),
            );
        }
    }
    #[inline]
    pub fn NetbiosOverTcpipEnabled(&self) -> ULONG {
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        let mask = 0x40 as u16;
        let val = (unit_field_val & mask) >> 6usize;
        unsafe { ::std::mem::transmute(val as u32) }
    }
    #[inline]
    pub fn set_NetbiosOverTcpipEnabled(&mut self, val: ULONG) {
        let mask = 0x40 as u16;
        let val = val as u32 as u16;
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 6usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &unit_field_val as *const _ as *const u8,
                &mut self._bitfield_1 as *mut _ as *mut u8,
                ::std::mem::size_of::<u16>(),
            );
        }
    }
    #[inline]
    pub fn Ipv4Enabled(&self) -> ULONG {
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        let mask = 0x80 as u16;
        let val = (unit_field_val & mask) >> 7usize;
        unsafe { ::std::mem::transmute(val as u32) }
    }
    #[inline]
    pub fn set_Ipv4Enabled(&mut self, val: ULONG) {
        let mask = 0x80 as u16;
        let val = val as u32 as u16;
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 7usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &unit_field_val as *const _ as *const u8,
                &mut self._bitfield_1 as *mut _ as *mut u8,
                ::std::mem::size_of::<u16>(),
            );
        }
    }
    #[inline]
    pub fn Ipv6Enabled(&self) -> ULONG {
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        let mask = 0x100 as u16;
        let val = (unit_field_val & mask) >> 8usize;
        unsafe { ::std::mem::transmute(val as u32) }
    }
    #[inline]
    pub fn set_Ipv6Enabled(&mut self, val: ULONG) {
        let mask = 0x100 as u16;
        let val = val as u32 as u16;
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 8usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &unit_field_val as *const _ as *const u8,
                &mut self._bitfield_1 as *mut _ as *mut u8,
                ::std::mem::size_of::<u16>(),
            );
        }
    }
    #[inline]
    pub fn Ipv6ManagedAddressConfigurationSupported(&self) -> ULONG {
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        let mask = 0x200 as u16;
        let val = (unit_field_val & mask) >> 9usize;
        unsafe { ::std::mem::transmute(val as u32) }
    }
    #[inline]
    pub fn set_Ipv6ManagedAddressConfigurationSupported(&mut self, val: ULONG) {
        let mask = 0x200 as u16;
        let val = val as u32 as u16;
        let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &self._bitfield_1 as *const _ as *const u8,
                &mut unit_field_val as *mut u16 as *mut u8,
                ::std::mem::size_of::<u16>(),
            )
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 9usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(
                &unit_field_val as *const _ as *const u8,
                &mut self._bitfield_1 as *mut _ as *mut u8,
                ::std::mem::size_of::<u16>(),
            );
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        DdnsEnabled: ULONG,
        RegisterAdapterSuffix: ULONG,
        Dhcpv4Enabled: ULONG,
        ReceiveOnly: ULONG,
        NoMulticast: ULONG,
        Ipv6OtherStatefulConfig: ULONG,
        NetbiosOverTcpipEnabled: ULONG,
        Ipv4Enabled: ULONG,
        Ipv6Enabled: ULONG,
        Ipv6ManagedAddressConfigurationSupported: ULONG,
    ) -> u16 {
        ((((((((((0 | ((DdnsEnabled as u32 as u16) << 0usize) & (0x1 as u16))
            | ((RegisterAdapterSuffix as u32 as u16) << 1usize) & (0x2 as u16))
            | ((Dhcpv4Enabled as u32 as u16) << 2usize) & (0x4 as u16))
            | ((ReceiveOnly as u32 as u16) << 3usize) & (0x8 as u16))
            | ((NoMulticast as u32 as u16) << 4usize) & (0x10 as u16))
            | ((Ipv6OtherStatefulConfig as u32 as u16) << 5usize) & (0x20 as u16))
            | ((NetbiosOverTcpipEnabled as u32 as u16) << 6usize) & (0x40 as u16))
            | ((Ipv4Enabled as u32 as u16) << 7usize) & (0x80 as u16))
            | ((Ipv6Enabled as u32 as u16) << 8usize) & (0x100 as u16))
            | ((Ipv6ManagedAddressConfigurationSupported as u32 as u16) << 9usize) & (0x200 as u16))
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2>(),
        4usize,
        concat!(
            "Size of: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2)).Flags as *const _ as usize
        },
        0usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2),
            "::",
            stringify!(Flags)
        )
    );
}
impl Clone for _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2 {
    fn clone(&self) -> Self {
        *self
    }
}
#[test]
fn bindgen_test_layout__IP_ADAPTER_ADDRESSES_LH() {
    assert_eq!(
        ::std::mem::size_of::<_IP_ADAPTER_ADDRESSES_LH>(),
        376usize,
        concat!("Size of: ", stringify!(_IP_ADAPTER_ADDRESSES_LH))
    );
    assert_eq!(
        ::std::mem::align_of::<_IP_ADAPTER_ADDRESSES_LH>(),
        8usize,
        concat!("Alignment of ", stringify!(_IP_ADAPTER_ADDRESSES_LH))
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).Next as *const _ as usize },
        8usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(Next)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).AdapterName as *const _ as usize },
        12usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(AdapterName)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).FirstUnicastAddress as *const _ as usize
        },
        16usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(FirstUnicastAddress)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).FirstAnycastAddress as *const _ as usize
        },
        20usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(FirstAnycastAddress)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).FirstMulticastAddress as *const _ as usize
        },
        24usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(FirstMulticastAddress)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).FirstDnsServerAddress as *const _ as usize
        },
        28usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(FirstDnsServerAddress)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).DnsSuffix as *const _ as usize },
        32usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(DnsSuffix)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).Description as *const _ as usize },
        36usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(Description)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).FriendlyName as *const _ as usize },
        40usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(FriendlyName)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).PhysicalAddress as *const _ as usize },
        44usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(PhysicalAddress)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).PhysicalAddressLength as *const _ as usize
        },
        52usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(PhysicalAddressLength)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).Mtu as *const _ as usize },
        60usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(Mtu)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).IfType as *const _ as usize },
        64usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(IfType)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).OperStatus as *const _ as usize },
        68usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(OperStatus)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).Ipv6IfIndex as *const _ as usize },
        72usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(Ipv6IfIndex)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).ZoneIndices as *const _ as usize },
        76usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(ZoneIndices)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).FirstPrefix as *const _ as usize },
        140usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(FirstPrefix)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).TransmitLinkSpeed as *const _ as usize
        },
        144usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(TransmitLinkSpeed)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).ReceiveLinkSpeed as *const _ as usize },
        152usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(ReceiveLinkSpeed)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).FirstWinsServerAddress as *const _ as usize
        },
        160usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(FirstWinsServerAddress)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).FirstGatewayAddress as *const _ as usize
        },
        164usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(FirstGatewayAddress)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).Ipv4Metric as *const _ as usize },
        168usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(Ipv4Metric)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).Ipv6Metric as *const _ as usize },
        172usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(Ipv6Metric)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).Luid as *const _ as usize },
        176usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(Luid)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).Dhcpv4Server as *const _ as usize },
        184usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(Dhcpv4Server)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).CompartmentId as *const _ as usize },
        192usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(CompartmentId)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).NetworkGuid as *const _ as usize },
        196usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(NetworkGuid)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).ConnectionType as *const _ as usize },
        212usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(ConnectionType)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).TunnelType as *const _ as usize },
        216usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(TunnelType)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).Dhcpv6Server as *const _ as usize },
        220usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(Dhcpv6Server)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).Dhcpv6ClientDuid as *const _ as usize },
        228usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(Dhcpv6ClientDuid)
        )
    );
    assert_eq!(
        unsafe {
            &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).Dhcpv6ClientDuidLength as *const _ as usize
        },
        360usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(Dhcpv6ClientDuidLength)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).Dhcpv6Iaid as *const _ as usize },
        364usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(Dhcpv6Iaid)
        )
    );
    assert_eq!(
        unsafe { &(*(0 as *const _IP_ADAPTER_ADDRESSES_LH)).FirstDnsSuffix as *const _ as usize },
        368usize,
        concat!(
            "Alignment of field: ",
            stringify!(_IP_ADAPTER_ADDRESSES_LH),
            "::",
            stringify!(FirstDnsSuffix)
        )
    );
}
impl Clone for _IP_ADAPTER_ADDRESSES_LH {
    fn clone(&self) -> Self {
        *self
    }
}
pub type IP_ADAPTER_ADDRESSES_LH = _IP_ADAPTER_ADDRESSES_LH;
pub type PIP_ADAPTER_ADDRESSES = *mut IP_ADAPTER_ADDRESSES_LH;
extern "stdcall" {
    #[link_name = "\u{1}_GetAdaptersAddresses@20"]
    pub fn GetAdaptersAddresses(
        Family: ULONG,
        Flags: ULONG,
        Reserved: PVOID,
        AdapterAddresses: PIP_ADAPTER_ADDRESSES,
        SizePointer: PULONG,
    ) -> ULONG;
}
