#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
pub mod root {
    #[allow(unused_imports)]
    use self::super::root;
    pub mod whatever {
        #[allow(unused_imports)]
        use self::super::super::root;
        #[repr(C)]
        #[derive(Debug, Default, Copy, Clone)]
        pub struct Wrapper {
            pub _address: u8,
        }
        #[repr(C)]
        #[derive(Debug, Default, Copy, Clone)]
        pub struct Wrapper_sentry {
            pub i_am_wrapper_sentry: ::std::os::raw::c_int,
        }
        #[repr(C)]
        #[derive(Debug, Default, Copy, Clone)]
        pub struct sentry {
            pub i_am_plain_sentry: bool,
        }
        #[test]
        fn bindgen_test_layout_sentry() {
            const UNINIT: ::std::mem::MaybeUninit<sentry> = ::std::mem::MaybeUninit::uninit();
            let ptr = UNINIT.as_ptr();
            assert_eq!(
                ::std::mem::size_of::<sentry>(),
                1usize,
                concat!("Size of: ", stringify!(sentry)),
            );
            assert_eq!(
                ::std::mem::align_of::<sentry>(),
                1usize,
                concat!("Alignment of ", stringify!(sentry)),
            );
            assert_eq!(
                unsafe {
                    ::std::ptr::addr_of!((*ptr).i_am_plain_sentry) as usize
                        - ptr as usize
                },
                0usize,
                concat!(
                    "Offset of field: ",
                    stringify!(sentry),
                    "::",
                    stringify!(i_am_plain_sentry),
                ),
            );
        }
        #[repr(C)]
        #[derive(Debug, Default, Copy, Clone)]
        pub struct NotTemplateWrapper {
            pub _address: u8,
        }
        #[test]
        fn bindgen_test_layout_NotTemplateWrapper() {
            assert_eq!(
                ::std::mem::size_of::<NotTemplateWrapper>(),
                1usize,
                concat!("Size of: ", stringify!(NotTemplateWrapper)),
            );
            assert_eq!(
                ::std::mem::align_of::<NotTemplateWrapper>(),
                1usize,
                concat!("Alignment of ", stringify!(NotTemplateWrapper)),
            );
        }
        #[repr(C)]
        #[derive(Debug, Default, Copy, Clone)]
        pub struct NotTemplateWrapper_sentry {
            pub i_am_not_template_wrapper_sentry: ::std::os::raw::c_char,
        }
        #[test]
        fn bindgen_test_layout_NotTemplateWrapper_sentry() {
            const UNINIT: ::std::mem::MaybeUninit<NotTemplateWrapper_sentry> = ::std::mem::MaybeUninit::uninit();
            let ptr = UNINIT.as_ptr();
            assert_eq!(
                ::std::mem::size_of::<NotTemplateWrapper_sentry>(),
                1usize,
                concat!("Size of: ", stringify!(NotTemplateWrapper_sentry)),
            );
            assert_eq!(
                ::std::mem::align_of::<NotTemplateWrapper_sentry>(),
                1usize,
                concat!("Alignment of ", stringify!(NotTemplateWrapper_sentry)),
            );
            assert_eq!(
                unsafe {
                    ::std::ptr::addr_of!((*ptr).i_am_not_template_wrapper_sentry)
                        as usize - ptr as usize
                },
                0usize,
                concat!(
                    "Offset of field: ",
                    stringify!(NotTemplateWrapper_sentry),
                    "::",
                    stringify!(i_am_not_template_wrapper_sentry),
                ),
            );
        }
        #[repr(C)]
        #[derive(Debug, Default, Copy, Clone)]
        pub struct InlineNotTemplateWrapper {
            pub _address: u8,
        }
        #[repr(C)]
        #[derive(Debug, Default, Copy, Clone)]
        pub struct InlineNotTemplateWrapper_sentry {
            pub i_am_inline_not_template_wrapper_sentry: bool,
        }
        #[test]
        fn bindgen_test_layout_InlineNotTemplateWrapper_sentry() {
            const UNINIT: ::std::mem::MaybeUninit<InlineNotTemplateWrapper_sentry> = ::std::mem::MaybeUninit::uninit();
            let ptr = UNINIT.as_ptr();
            assert_eq!(
                ::std::mem::size_of::<InlineNotTemplateWrapper_sentry>(),
                1usize,
                concat!("Size of: ", stringify!(InlineNotTemplateWrapper_sentry)),
            );
            assert_eq!(
                ::std::mem::align_of::<InlineNotTemplateWrapper_sentry>(),
                1usize,
                concat!("Alignment of ", stringify!(InlineNotTemplateWrapper_sentry)),
            );
            assert_eq!(
                unsafe {
                    ::std::ptr::addr_of!((*ptr).i_am_inline_not_template_wrapper_sentry)
                        as usize - ptr as usize
                },
                0usize,
                concat!(
                    "Offset of field: ",
                    stringify!(InlineNotTemplateWrapper_sentry),
                    "::",
                    stringify!(i_am_inline_not_template_wrapper_sentry),
                ),
            );
        }
        #[test]
        fn bindgen_test_layout_InlineNotTemplateWrapper() {
            assert_eq!(
                ::std::mem::size_of::<InlineNotTemplateWrapper>(),
                1usize,
                concat!("Size of: ", stringify!(InlineNotTemplateWrapper)),
            );
            assert_eq!(
                ::std::mem::align_of::<InlineNotTemplateWrapper>(),
                1usize,
                concat!("Alignment of ", stringify!(InlineNotTemplateWrapper)),
            );
        }
        #[repr(C)]
        #[derive(Debug, Default, Copy, Clone)]
        pub struct InlineTemplateWrapper {
            pub _address: u8,
        }
        #[repr(C)]
        #[derive(Debug, Default, Copy, Clone)]
        pub struct InlineTemplateWrapper_sentry {
            pub i_am_inline_template_wrapper_sentry: ::std::os::raw::c_int,
        }
        #[repr(C)]
        #[derive(Debug, Default, Copy, Clone)]
        pub struct OuterDoubleWrapper {
            pub _address: u8,
        }
        #[repr(C)]
        #[derive(Debug, Default, Copy, Clone)]
        pub struct OuterDoubleWrapper_InnerDoubleWrapper {
            pub _address: u8,
        }
        #[test]
        fn bindgen_test_layout_OuterDoubleWrapper_InnerDoubleWrapper() {
            assert_eq!(
                ::std::mem::size_of::<OuterDoubleWrapper_InnerDoubleWrapper>(),
                1usize,
                concat!("Size of: ", stringify!(OuterDoubleWrapper_InnerDoubleWrapper)),
            );
            assert_eq!(
                ::std::mem::align_of::<OuterDoubleWrapper_InnerDoubleWrapper>(),
                1usize,
                concat!(
                    "Alignment of ",
                    stringify!(OuterDoubleWrapper_InnerDoubleWrapper),
                ),
            );
        }
        #[test]
        fn bindgen_test_layout_OuterDoubleWrapper() {
            assert_eq!(
                ::std::mem::size_of::<OuterDoubleWrapper>(),
                1usize,
                concat!("Size of: ", stringify!(OuterDoubleWrapper)),
            );
            assert_eq!(
                ::std::mem::align_of::<OuterDoubleWrapper>(),
                1usize,
                concat!("Alignment of ", stringify!(OuterDoubleWrapper)),
            );
        }
        #[repr(C)]
        #[derive(Debug, Default, Copy, Clone)]
        pub struct OuterDoubleWrapper_InnerDoubleWrapper_sentry {
            pub i_am_double_wrapper_sentry: ::std::os::raw::c_int,
        }
        #[test]
        fn bindgen_test_layout_OuterDoubleWrapper_InnerDoubleWrapper_sentry() {
            const UNINIT: ::std::mem::MaybeUninit<
                OuterDoubleWrapper_InnerDoubleWrapper_sentry,
            > = ::std::mem::MaybeUninit::uninit();
            let ptr = UNINIT.as_ptr();
            assert_eq!(
                ::std::mem::size_of::<OuterDoubleWrapper_InnerDoubleWrapper_sentry>(),
                4usize,
                concat!(
                    "Size of: ",
                    stringify!(OuterDoubleWrapper_InnerDoubleWrapper_sentry),
                ),
            );
            assert_eq!(
                ::std::mem::align_of::<OuterDoubleWrapper_InnerDoubleWrapper_sentry>(),
                4usize,
                concat!(
                    "Alignment of ",
                    stringify!(OuterDoubleWrapper_InnerDoubleWrapper_sentry),
                ),
            );
            assert_eq!(
                unsafe {
                    ::std::ptr::addr_of!((*ptr).i_am_double_wrapper_sentry) as usize
                        - ptr as usize
                },
                0usize,
                concat!(
                    "Offset of field: ",
                    stringify!(OuterDoubleWrapper_InnerDoubleWrapper_sentry),
                    "::",
                    stringify!(i_am_double_wrapper_sentry),
                ),
            );
        }
        #[repr(C)]
        #[derive(Debug, Default, Copy, Clone)]
        pub struct OuterDoubleInlineWrapper {
            pub _address: u8,
        }
        #[repr(C)]
        #[derive(Debug, Default, Copy, Clone)]
        pub struct OuterDoubleInlineWrapper_InnerDoubleInlineWrapper {
            pub _address: u8,
        }
        #[repr(C)]
        #[derive(Debug, Default, Copy, Clone)]
        pub struct OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry {
            pub i_am_double_wrapper_inline_sentry: ::std::os::raw::c_int,
        }
        #[test]
        fn bindgen_test_layout_OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry() {
            const UNINIT: ::std::mem::MaybeUninit<
                OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry,
            > = ::std::mem::MaybeUninit::uninit();
            let ptr = UNINIT.as_ptr();
            assert_eq!(
                ::std::mem::size_of::<
                    OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry,
                >(),
                4usize,
                concat!(
                    "Size of: ",
                    stringify!(OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry),
                ),
            );
            assert_eq!(
                ::std::mem::align_of::<
                    OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry,
                >(),
                4usize,
                concat!(
                    "Alignment of ",
                    stringify!(OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry),
                ),
            );
            assert_eq!(
                unsafe {
                    ::std::ptr::addr_of!((*ptr).i_am_double_wrapper_inline_sentry)
                        as usize - ptr as usize
                },
                0usize,
                concat!(
                    "Offset of field: ",
                    stringify!(OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry),
                    "::",
                    stringify!(i_am_double_wrapper_inline_sentry),
                ),
            );
        }
        #[test]
        fn bindgen_test_layout_OuterDoubleInlineWrapper_InnerDoubleInlineWrapper() {
            assert_eq!(
                ::std::mem::size_of::<
                    OuterDoubleInlineWrapper_InnerDoubleInlineWrapper,
                >(),
                1usize,
                concat!(
                    "Size of: ",
                    stringify!(OuterDoubleInlineWrapper_InnerDoubleInlineWrapper),
                ),
            );
            assert_eq!(
                ::std::mem::align_of::<
                    OuterDoubleInlineWrapper_InnerDoubleInlineWrapper,
                >(),
                1usize,
                concat!(
                    "Alignment of ",
                    stringify!(OuterDoubleInlineWrapper_InnerDoubleInlineWrapper),
                ),
            );
        }
        #[test]
        fn bindgen_test_layout_OuterDoubleInlineWrapper() {
            assert_eq!(
                ::std::mem::size_of::<OuterDoubleInlineWrapper>(),
                1usize,
                concat!("Size of: ", stringify!(OuterDoubleInlineWrapper)),
            );
            assert_eq!(
                ::std::mem::align_of::<OuterDoubleInlineWrapper>(),
                1usize,
                concat!("Alignment of ", stringify!(OuterDoubleInlineWrapper)),
            );
        }
    }
    #[repr(C)]
    #[derive(Debug, Default, Copy, Clone)]
    pub struct OutsideNamespaceWrapper {
        pub _address: u8,
    }
    #[repr(C)]
    #[derive(Debug, Default, Copy, Clone)]
    pub struct OutsideNamespaceWrapper_sentry {
        pub i_am_outside_namespace_wrapper_sentry: ::std::os::raw::c_int,
    }
    #[repr(C)]
    #[derive(Debug, Default, Copy, Clone)]
    pub struct sentry {
        pub i_am_outside_namespace_sentry: ::std::os::raw::c_int,
    }
    #[test]
    fn bindgen_test_layout_sentry() {
        const UNINIT: ::std::mem::MaybeUninit<sentry> = ::std::mem::MaybeUninit::uninit();
        let ptr = UNINIT.as_ptr();
        assert_eq!(
            ::std::mem::size_of::<sentry>(),
            4usize,
            concat!("Size of: ", stringify!(sentry)),
        );
        assert_eq!(
            ::std::mem::align_of::<sentry>(),
            4usize,
            concat!("Alignment of ", stringify!(sentry)),
        );
        assert_eq!(
            unsafe {
                ::std::ptr::addr_of!((*ptr).i_am_outside_namespace_sentry) as usize
                    - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(sentry),
                "::",
                stringify!(i_am_outside_namespace_sentry),
            ),
        );
    }
}
