cpp_std/

lib.rs

//! This crate was generated by `ritual`.
//!                     See [README](https://github.com/rust-qt/ritual) for more information.

mod __ffi {
    //! Functions provided by the C++ wrapper library

    include!(concat!(env!("OUT_DIR"), "/ffi.rs"));
}
pub use ::cpp_core;
/// C++ class: <span style='color: green;'>```std::piecewise_construct_t```</span>.
#[repr(C)]
pub struct PiecewiseConstructT {
    _unused: u8,
}
impl PiecewiseConstructT {
    /// Calls C++ function: <span style='color: green;'>```std::piecewise_construct_t& std::piecewise_construct_t::operator=(const std::piecewise_construct_t& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::PiecewiseConstructT>>,
    ) -> ::cpp_core::MutRef<crate::PiecewiseConstructT> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_piecewise_construct_t_operator_(
            self as *mut crate::PiecewiseConstructT,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::PiecewiseConstructT>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::piecewise_construct_t::piecewise_construct_t()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::PiecewiseConstructT> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_piecewise_construct_t_piecewise_construct_t();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::piecewise_construct_t::piecewise_construct_t(const std::piecewise_construct_t& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::PiecewiseConstructT>>,
    ) -> ::cpp_core::CppBox<crate::PiecewiseConstructT> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_piecewise_construct_t_piecewise_construct_t1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::PiecewiseConstructT>>::cast_into(
                    other,
                )
                .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::input_iterator_tag```</span>.
#[repr(C)]
pub struct InputIteratorTag {
    _unused: u8,
}
impl InputIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::input_iterator_tag& std::input_iterator_tag::operator=(const std::input_iterator_tag& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::InputIteratorTag>>,
    ) -> ::cpp_core::MutRef<crate::InputIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_input_iterator_tag_operator_(
            self as *mut crate::InputIteratorTag,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::InputIteratorTag>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::input_iterator_tag::input_iterator_tag()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::InputIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_input_iterator_tag_input_iterator_tag();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::input_iterator_tag::input_iterator_tag(const std::input_iterator_tag& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::InputIteratorTag>>,
    ) -> ::cpp_core::CppBox<crate::InputIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_input_iterator_tag_input_iterator_tag1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::InputIteratorTag>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::output_iterator_tag```</span>.
#[repr(C)]
pub struct OutputIteratorTag {
    _unused: u8,
}
impl OutputIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::output_iterator_tag& std::output_iterator_tag::operator=(const std::output_iterator_tag& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::OutputIteratorTag>>,
    ) -> ::cpp_core::MutRef<crate::OutputIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_output_iterator_tag_operator_(
            self as *mut crate::OutputIteratorTag,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::OutputIteratorTag>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::output_iterator_tag::output_iterator_tag()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::OutputIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_output_iterator_tag_output_iterator_tag();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::output_iterator_tag::output_iterator_tag(const std::output_iterator_tag& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::OutputIteratorTag>>,
    ) -> ::cpp_core::CppBox<crate::OutputIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_output_iterator_tag_output_iterator_tag1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::OutputIteratorTag>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::forward_iterator_tag```</span>.
#[repr(C)]
pub struct ForwardIteratorTag {
    _unused: u8,
}
impl ForwardIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::forward_iterator_tag& std::forward_iterator_tag::operator=(const std::forward_iterator_tag& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::ForwardIteratorTag>>,
    ) -> ::cpp_core::MutRef<crate::ForwardIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_forward_iterator_tag_operator_(
            self as *mut crate::ForwardIteratorTag,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::ForwardIteratorTag>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::forward_iterator_tag::forward_iterator_tag()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::ForwardIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_forward_iterator_tag_forward_iterator_tag();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::forward_iterator_tag::forward_iterator_tag(const std::forward_iterator_tag& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::ForwardIteratorTag>>,
    ) -> ::cpp_core::CppBox<crate::ForwardIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_forward_iterator_tag_forward_iterator_tag1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::ForwardIteratorTag>>::cast_into(
                    other,
                )
                .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::bidirectional_iterator_tag```</span>.
#[repr(C)]
pub struct BidirectionalIteratorTag {
    _unused: u8,
}
impl BidirectionalIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::bidirectional_iterator_tag& std::bidirectional_iterator_tag::operator=(const std::bidirectional_iterator_tag& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::BidirectionalIteratorTag>>,
    ) -> ::cpp_core::MutRef<crate::BidirectionalIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_bidirectional_iterator_tag_operator_(
            self as *mut crate::BidirectionalIteratorTag,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::BidirectionalIteratorTag>>::cast_into(
                other,
            )
            .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::bidirectional_iterator_tag::bidirectional_iterator_tag()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::BidirectionalIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_bidirectional_iterator_tag_bidirectional_iterator_tag(
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::bidirectional_iterator_tag::bidirectional_iterator_tag(const std::bidirectional_iterator_tag& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::BidirectionalIteratorTag>>,
    ) -> ::cpp_core::CppBox<crate::BidirectionalIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_bidirectional_iterator_tag_bidirectional_iterator_tag1(::cpp_core::CastInto::<::cpp_core::Ref<crate::BidirectionalIteratorTag>>::cast_into(other).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::random_access_iterator_tag```</span>.
#[repr(C)]
pub struct RandomAccessIteratorTag {
    _unused: u8,
}
impl RandomAccessIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::random_access_iterator_tag& std::random_access_iterator_tag::operator=(const std::random_access_iterator_tag& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::RandomAccessIteratorTag>>,
    ) -> ::cpp_core::MutRef<crate::RandomAccessIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_random_access_iterator_tag_operator_(
            self as *mut crate::RandomAccessIteratorTag,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::RandomAccessIteratorTag>>::cast_into(
                other,
            )
            .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::random_access_iterator_tag::random_access_iterator_tag()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::RandomAccessIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_random_access_iterator_tag_random_access_iterator_tag(
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::random_access_iterator_tag::random_access_iterator_tag(const std::random_access_iterator_tag& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::RandomAccessIteratorTag>>,
    ) -> ::cpp_core::CppBox<crate::RandomAccessIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_random_access_iterator_tag_random_access_iterator_tag1(::cpp_core::CastInto::<::cpp_core::Ref<crate::RandomAccessIteratorTag>>::cast_into(other).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::iterator<std::output_iterator_tag, void, void, void, void>```</span>.
#[repr(C)]
pub struct IteratorOfOutputIteratorTag {
    _unused: u8,
}
impl IteratorOfOutputIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::iterator<std::output_iterator_tag, void, void, void, void>& std::iterator<std::output_iterator_tag, void, void, void, void>::operator=(const std::iterator<std::output_iterator_tag, void, void, void, void>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::IteratorOfOutputIteratorTag>>,
    ) -> ::cpp_core::MutRef<crate::IteratorOfOutputIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_iterator_std_output_iterator_tag_void_void_void_void_operator_(self as *mut crate::IteratorOfOutputIteratorTag, ::cpp_core::CastInto::<::cpp_core::Ref<crate::IteratorOfOutputIteratorTag>>::cast_into(other).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::iterator<std::output_iterator_tag, void, void, void, void>::iterator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::IteratorOfOutputIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_iterator_std_output_iterator_tag_void_void_void_void_iterator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::iterator<std::output_iterator_tag, void, void, void, void>::iterator(const std::iterator<std::output_iterator_tag, void, void, void, void>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::IteratorOfOutputIteratorTag>>,
    ) -> ::cpp_core::CppBox<crate::IteratorOfOutputIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_iterator_std_output_iterator_tag_void_void_void_void_iterator1(::cpp_core::CastInto::<::cpp_core::Ref<crate::IteratorOfOutputIteratorTag>>::cast_into(other).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::char_traits<char>```</span>.
#[repr(C)]
pub struct CharTraitsOfChar {
    _unused: u8,
}
impl CharTraitsOfChar {
    /// Calls C++ function: <span style='color: green;'>```std::char_traits<char>& std::char_traits<char>::operator=(const std::char_traits<char>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::CharTraitsOfChar>>,
    ) -> ::cpp_core::MutRef<crate::CharTraitsOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_char_traits_char_operator_(
            self as *mut crate::CharTraitsOfChar,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::CharTraitsOfChar>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::char_traits<char>::char_traits()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::CharTraitsOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_char_traits_char_char_traits();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::char_traits<char>::char_traits(const std::char_traits<char>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::CharTraitsOfChar>>,
    ) -> ::cpp_core::CppBox<crate::CharTraitsOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_char_traits_char_char_traits1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::CharTraitsOfChar>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>```</span>.
#[repr(C)]
pub struct String {
    _unused: u8,
}
impl String {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::append(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str)```</span>.
    pub unsafe fn append_string(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_append(self as *mut crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::append(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos, size_t __n = …)```</span>.
    pub unsafe fn append_string2_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos: usize,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_append1(self as *mut crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::append(const char* __s, size_t __n)```</span>.
    pub unsafe fn append_char_usize(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_append2(self as *mut crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::append(const char* __s)```</span>.
    pub unsafe fn append_char(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_append3(self as *mut crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::append(size_t __n, char __c)```</span>.
    pub unsafe fn append_usize_char(
        &mut self,
        n: usize,
        c: ::std::os::raw::c_char,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_append4(self as *mut crate::String, n, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::append(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos)```</span>.
    pub unsafe fn append_string_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos: usize,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_append5(self as *mut crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::assign(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str)```</span>.
    pub unsafe fn assign_string(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_assign(self as *mut crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::assign(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos, size_t __n = …)```</span>.
    pub unsafe fn assign_string2_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos: usize,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_assign2(self as *mut crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::assign(const char* __s, size_t __n)```</span>.
    pub unsafe fn assign_char_usize(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_assign3(self as *mut crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::assign(const char* __s)```</span>.
    pub unsafe fn assign_char(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_assign4(self as *mut crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::assign(size_t __n, char __c)```</span>.
    pub unsafe fn assign_usize_char(
        &mut self,
        n: usize,
        c: ::std::os::raw::c_char,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_assign5(self as *mut crate::String, n, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::assign(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos)```</span>.
    pub unsafe fn assign_string_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos: usize,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_assign6(self as *mut crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_at(self as *const crate::String, n);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_at1(self as *mut crate::String, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_back(self as *mut crate::String);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_back1(self as *const crate::String);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char* std::basic_string<char, std::char_traits<char>, std::allocator<char>>::c_str() const```</span>.
    pub unsafe fn c_str(&self) -> ::cpp_core::Ptr<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_c_str(self as *const crate::String);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_capacity(self as *const crate::String)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_clear(self as *mut crate::String)
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char, std::char_traits<char>, std::allocator<char>>::compare(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str) const```</span>.
    pub unsafe fn compare_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_compare(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char, std::char_traits<char>, std::allocator<char>>::compare(size_t __pos, size_t __n, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str) const```</span>.
    pub unsafe fn compare_2_usize_string(
        &self,
        pos: usize,
        n: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_compare1(self as *const crate::String, pos, n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char, std::char_traits<char>, std::allocator<char>>::compare(size_t __pos1, size_t __n1, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos2, size_t __n2 = …) const```</span>.
    pub unsafe fn compare_2_usize_string2_usize(
        &self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos2: usize,
        n2: usize,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_compare2(self as *const crate::String, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos2, n2)
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char, std::char_traits<char>, std::allocator<char>>::compare(const char* __s) const```</span>.
    pub unsafe fn compare_char(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_compare3(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char, std::char_traits<char>, std::allocator<char>>::compare(size_t __pos, size_t __n1, const char* __s) const```</span>.
    pub unsafe fn compare_2_usize_char(
        &self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_compare4(self as *const crate::String, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char, std::char_traits<char>, std::allocator<char>>::compare(size_t __pos, size_t __n1, const char* __s, size_t __n2) const```</span>.
    pub unsafe fn compare_2_usize_char_usize(
        &self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        n2: usize,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_compare5(self as *const crate::String, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), n2)
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char, std::char_traits<char>, std::allocator<char>>::compare(size_t __pos1, size_t __n1, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos2) const```</span>.
    pub unsafe fn compare_2_usize_string_usize(
        &self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos2: usize,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_compare6(self as *const crate::String, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos2)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::copy(char* __s, size_t __n, size_t __pos = …) const```</span>.
    pub unsafe fn copy_3a(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::MutPtr<::std::os::raw::c_char>>,
        n: usize,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_copy(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::MutPtr<::std::os::raw::c_char>>::cast_into(s).as_mut_raw_ptr(), n, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::copy(char* __s, size_t __n) const```</span>.
    pub unsafe fn copy_2a(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::MutPtr<::std::os::raw::c_char>>,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_copy1(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::MutPtr<::std::os::raw::c_char>>::cast_into(s).as_mut_raw_ptr(), n)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::operator=(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str)```</span>.
    pub unsafe fn copy_from_string(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_operator_(self as *mut crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::operator=(const char* __s)```</span>.
    pub unsafe fn copy_from_char(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_operator_1(self as *mut crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::operator=(char __c)```</span>.
    pub unsafe fn copy_from_char2(
        &mut self,
        c: ::std::os::raw::c_char,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_operator_2(self as *mut crate::String, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char* std::basic_string<char, std::char_traits<char>, std::allocator<char>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_data(self as *const crate::String);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::basic_string<char, std::char_traits<char>, std::allocator<char>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_empty(self as *const crate::String)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::erase(size_t __pos = …, size_t __n = …)```</span>.
    pub unsafe fn erase_2a(&mut self, pos: usize, n: usize) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_erase(self as *mut crate::String, pos, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::erase(size_t __pos = …)```</span>.
    pub unsafe fn erase_1a(&mut self, pos: usize) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_erase1(self as *mut crate::String, pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::erase()```</span>.
    pub unsafe fn erase_0a(&mut self) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_erase2(self as *mut crate::String);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find(const char* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_char2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find1(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find(const char* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_char_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find2(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find(char __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_char_usize2(&self, c: ::std::os::raw::c_char, pos: usize) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find3(self as *const crate::String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str) const```</span>.
    pub unsafe fn find_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find4(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find(const char* __s) const```</span>.
    pub unsafe fn find_char(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find5(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find(char __c) const```</span>.
    pub unsafe fn find_char2(&self, c: ::std::os::raw::c_char) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find6(self as *const crate::String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_not_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_not_of_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_first_not_of(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_not_of(const char* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_first_not_of_char2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_first_not_of1(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_not_of(const char* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_not_of_char_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_first_not_of2(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_not_of(char __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_not_of_char_usize2(
        &self,
        c: ::std::os::raw::c_char,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_first_not_of3(self as *const crate::String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_not_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str) const```</span>.
    pub unsafe fn find_first_not_of_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_first_not_of4(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_not_of(const char* __s) const```</span>.
    pub unsafe fn find_first_not_of_char(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_first_not_of5(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_not_of(char __c) const```</span>.
    pub unsafe fn find_first_not_of_char2(&self, c: ::std::os::raw::c_char) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_first_not_of6(self as *const crate::String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_of_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_first_of(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_of(const char* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_first_of_char2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_first_of1(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_of(const char* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_of_char_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_first_of2(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_of(char __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_of_char_usize2(&self, c: ::std::os::raw::c_char, pos: usize) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_first_of3(self as *const crate::String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str) const```</span>.
    pub unsafe fn find_first_of_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_first_of4(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_of(const char* __s) const```</span>.
    pub unsafe fn find_first_of_char(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_first_of5(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_of(char __c) const```</span>.
    pub unsafe fn find_first_of_char2(&self, c: ::std::os::raw::c_char) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_first_of6(self as *const crate::String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_not_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_not_of_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_last_not_of(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_not_of(const char* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_last_not_of_char2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_last_not_of1(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_not_of(const char* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_not_of_char_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_last_not_of2(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_not_of(char __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_not_of_char_usize2(
        &self,
        c: ::std::os::raw::c_char,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_last_not_of3(self as *const crate::String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_not_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str) const```</span>.
    pub unsafe fn find_last_not_of_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_last_not_of4(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_not_of(const char* __s) const```</span>.
    pub unsafe fn find_last_not_of_char(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_last_not_of5(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_not_of(char __c) const```</span>.
    pub unsafe fn find_last_not_of_char2(&self, c: ::std::os::raw::c_char) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_last_not_of6(self as *const crate::String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_of_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_last_of(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_of(const char* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_last_of_char2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_last_of1(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_of(const char* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_of_char_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_last_of2(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_of(char __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_of_char_usize2(&self, c: ::std::os::raw::c_char, pos: usize) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_last_of3(self as *const crate::String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_of(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str) const```</span>.
    pub unsafe fn find_last_of_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_last_of4(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_of(const char* __s) const```</span>.
    pub unsafe fn find_last_of_char(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_last_of5(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_of(char __c) const```</span>.
    pub unsafe fn find_last_of_char2(&self, c: ::std::os::raw::c_char) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_find_last_of6(self as *const crate::String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```char& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_front(self as *mut crate::String);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_front1(self as *const crate::String);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::operator[](size_t __pos) const```</span>.
    pub unsafe fn index(&self, pos: usize) -> ::cpp_core::Ref<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_operator__(self as *const crate::String, pos);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::operator[](size_t __pos)```</span>.
    pub unsafe fn index_mut(&mut self, pos: usize) -> ::cpp_core::MutRef<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_operator__1(self as *mut crate::String, pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::insert(size_t __pos1, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str)```</span>.
    pub unsafe fn insert_usize_string(
        &mut self,
        pos1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_insert(self as *mut crate::String, pos1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::insert(size_t __pos1, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos2, size_t __n = …)```</span>.
    pub unsafe fn insert_usize_string2_usize(
        &mut self,
        pos1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos2: usize,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_insert1(self as *mut crate::String, pos1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos2, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::insert(size_t __pos, const char* __s, size_t __n)```</span>.
    pub unsafe fn insert_usize_char_usize(
        &mut self,
        pos: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_insert2(self as *mut crate::String, pos, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::insert(size_t __pos, const char* __s)```</span>.
    pub unsafe fn insert_usize_char(
        &mut self,
        pos: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_insert3(self as *mut crate::String, pos, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::insert(size_t __pos, size_t __n, char __c)```</span>.
    pub unsafe fn insert_2_usize_char(
        &mut self,
        pos: usize,
        n: usize,
        c: ::std::os::raw::c_char,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_insert4(self as *mut crate::String, pos, n, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::insert(size_t __pos1, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos2)```</span>.
    pub unsafe fn insert_usize_string_usize(
        &mut self,
        pos1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos2: usize,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_insert5(self as *mut crate::String, pos1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::length() const```</span>.
    pub unsafe fn length(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_length(self as *const crate::String)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_max_size(self as *const crate::String)
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_basic_string();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(const std::allocator<char>& __a)```</span>.
    pub unsafe fn from_allocator_of_char(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar>>,
    ) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_basic_string1(::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos, const std::allocator<char>& __a = …)```</span>.
    pub unsafe fn from_string_usize_allocator_of_char(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar>>,
    ) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_basic_string3(::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos, size_t __n)```</span>.
    pub unsafe fn from_string2_usize(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos: usize,
        n: usize,
    ) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_basic_string4(::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos, n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos, size_t __n, const std::allocator<char>& __a)```</span>.
    pub unsafe fn from_string2_usize_allocator_of_char(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos: usize,
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar>>,
    ) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_basic_string5(::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos, n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(const char* __s, size_t __n, const std::allocator<char>& __a = …)```</span>.
    pub unsafe fn from_char_usize_allocator_of_char(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar>>,
    ) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_basic_string6(::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(const char* __s, const std::allocator<char>& __a = …)```</span>.
    pub unsafe fn from_char_allocator_of_char(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar>>,
    ) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_basic_string7(::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(size_t __n, char __c, const std::allocator<char>& __a = …)```</span>.
    pub unsafe fn from_usize_char_allocator_of_char(
        n: usize,
        c: ::std::os::raw::c_char,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar>>,
    ) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_basic_string8(n, c, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, const std::allocator<char>& __a)```</span>.
    pub unsafe fn from_string_allocator_of_char(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar>>,
    ) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_basic_string10(::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos)```</span>.
    pub unsafe fn from_string_usize(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos: usize,
    ) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_basic_string12(::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(const char* __s, size_t __n)```</span>.
    pub unsafe fn from_char_usize(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        n: usize,
    ) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_basic_string13(::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(const char* __s)```</span>.
    pub unsafe fn from_char(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_basic_string14(::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(size_t __n, char __c)```</span>.
    pub unsafe fn from_usize_char(
        n: usize,
        c: ::std::os::raw::c_char,
    ) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_basic_string15(n, c);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str)```</span>.
    pub unsafe fn new_copy(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    ) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_basic_string2(::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_pop_back(self as *mut crate::String)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::push_back(char __c)```</span>.
    pub unsafe fn push_back(&mut self, c: ::std::os::raw::c_char) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_push_back(self as *mut crate::String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::replace(size_t __pos, size_t __n, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str)```</span>.
    pub unsafe fn replace_2_usize_string(
        &mut self,
        pos: usize,
        n: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_replace(self as *mut crate::String, pos, n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::replace(size_t __pos1, size_t __n1, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos2, size_t __n2 = …)```</span>.
    pub unsafe fn replace_2_usize_string2_usize(
        &mut self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos2: usize,
        n2: usize,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_replace1(self as *mut crate::String, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos2, n2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::replace(size_t __pos, size_t __n1, const char* __s, size_t __n2)```</span>.
    pub unsafe fn replace_2_usize_char_usize(
        &mut self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        n2: usize,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_replace2(self as *mut crate::String, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), n2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::replace(size_t __pos, size_t __n1, const char* __s)```</span>.
    pub unsafe fn replace_2_usize_char(
        &mut self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_replace3(self as *mut crate::String, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::replace(size_t __pos, size_t __n1, size_t __n2, char __c)```</span>.
    pub unsafe fn replace_3_usize_char(
        &mut self,
        pos: usize,
        n1: usize,
        n2: usize,
        c: ::std::os::raw::c_char,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_replace4(self as *mut crate::String, pos, n1, n2, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::replace(size_t __pos1, size_t __n1, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos2)```</span>.
    pub unsafe fn replace_2_usize_string_usize(
        &mut self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos2: usize,
    ) -> ::cpp_core::MutRef<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_replace5(self as *mut crate::String, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::reserve(size_t __res_arg = …)```</span>.
    pub unsafe fn reserve_1a(&mut self, res_arg: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_reserve(self as *mut crate::String, res_arg)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::reserve()```</span>.
    pub unsafe fn reserve_0a(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_reserve1(self as *mut crate::String)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::resize(size_t __n, char __c)```</span>.
    pub unsafe fn resize_2a(&mut self, n: usize, c: ::std::os::raw::c_char) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_resize(self as *mut crate::String, n, c)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::resize(size_t __n)```</span>.
    pub unsafe fn resize_1a(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_resize1(self as *mut crate::String, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::rfind(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn rfind_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_rfind(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::rfind(const char* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn rfind_char2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_rfind1(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::rfind(const char* __s, size_t __pos = …) const```</span>.
    pub unsafe fn rfind_char_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_rfind2(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::rfind(char __c, size_t __pos = …) const```</span>.
    pub unsafe fn rfind_char_usize2(&self, c: ::std::os::raw::c_char, pos: usize) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_rfind3(self as *const crate::String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::rfind(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str) const```</span>.
    pub unsafe fn rfind_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_rfind4(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::rfind(const char* __s) const```</span>.
    pub unsafe fn rfind_char(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_rfind5(self as *const crate::String, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::rfind(char __c) const```</span>.
    pub unsafe fn rfind_char2(&self, c: ::std::os::raw::c_char) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_rfind6(self as *const crate::String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_shrink_to_fit(self as *mut crate::String)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_size(self as *const crate::String)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::basic_string<char, std::char_traits<char>, std::allocator<char>>::substr(size_t __pos = …, size_t __n = …) const```</span>.
    pub unsafe fn substr_2a(&self, pos: usize, n: usize) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_substr(self as *const crate::String, pos, n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::basic_string<char, std::char_traits<char>, std::allocator<char>>::substr(size_t __pos = …) const```</span>.
    pub unsafe fn substr_1a(&self, pos: usize) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_substr1(self as *const crate::String, pos);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::basic_string<char, std::char_traits<char>, std::allocator<char>>::substr() const```</span>.
    pub unsafe fn substr_0a(&self) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_substr2(self as *const crate::String);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::swap(std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __s)```</span>.
    pub unsafe fn swap(&mut self, s: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::String>>) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_swap(self as *mut crate::String, ::cpp_core::CastInto::<::cpp_core::MutRef<crate::String>>::cast_into(s).as_mut_raw_ptr())
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<char>```</span>.
#[repr(C)]
pub struct AllocatorOfChar {
    _unused: u8,
}
impl AllocatorOfChar {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<char>& std::allocator<char>::operator=(const std::allocator<char>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_char_operator_(
            self as *mut crate::AllocatorOfChar,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<char>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_char_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<char>::allocator(const std::allocator<char>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_char_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::char_traits<wchar_t>```</span>.
#[repr(C)]
pub struct CharTraitsOfWcharT {
    _unused: u8,
}
impl CharTraitsOfWcharT {
    /// Calls C++ function: <span style='color: green;'>```std::char_traits<wchar_t>& std::char_traits<wchar_t>::operator=(const std::char_traits<wchar_t>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::CharTraitsOfWcharT>>,
    ) -> ::cpp_core::MutRef<crate::CharTraitsOfWcharT> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_char_traits_wchar_t_operator_(
            self as *mut crate::CharTraitsOfWcharT,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::CharTraitsOfWcharT>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::char_traits<wchar_t>::char_traits()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::CharTraitsOfWcharT> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_char_traits_wchar_t_char_traits();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::char_traits<wchar_t>::char_traits(const std::char_traits<wchar_t>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::CharTraitsOfWcharT>>,
    ) -> ::cpp_core::CppBox<crate::CharTraitsOfWcharT> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_char_traits_wchar_t_char_traits1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::CharTraitsOfWcharT>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>```</span>.
#[repr(C)]
pub struct WString {
    _unused: u8,
}
impl WString {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::append(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str)```</span>.
    pub unsafe fn append_w_string(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_append(self as *mut crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::append(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos, size_t __n = …)```</span>.
    pub unsafe fn append_w_string2_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos: usize,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_append1(self as *mut crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::append(const wchar_t* __s, size_t __n)```</span>.
    pub unsafe fn append_wchar_t_usize(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_append2(self as *mut crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::append(const wchar_t* __s)```</span>.
    pub unsafe fn append_wchar_t(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_append3(self as *mut crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::append(size_t __n, wchar_t __c)```</span>.
    pub unsafe fn append_usize_wchar_t(
        &mut self,
        n: usize,
        c: ::cpp_core::wchar_t,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_append4(self as *mut crate::WString, n, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::append(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos)```</span>.
    pub unsafe fn append_w_string_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos: usize,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_append5(self as *mut crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::assign(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str)```</span>.
    pub unsafe fn assign_w_string(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_assign(self as *mut crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::assign(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos, size_t __n = …)```</span>.
    pub unsafe fn assign_w_string2_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos: usize,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_assign2(self as *mut crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::assign(const wchar_t* __s, size_t __n)```</span>.
    pub unsafe fn assign_wchar_t_usize(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_assign3(self as *mut crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::assign(const wchar_t* __s)```</span>.
    pub unsafe fn assign_wchar_t(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_assign4(self as *mut crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::assign(size_t __n, wchar_t __c)```</span>.
    pub unsafe fn assign_usize_wchar_t(
        &mut self,
        n: usize,
        c: ::cpp_core::wchar_t,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_assign5(self as *mut crate::WString, n, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::assign(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos)```</span>.
    pub unsafe fn assign_w_string_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos: usize,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_assign6(self as *mut crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const wchar_t& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::cpp_core::wchar_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_at(self as *const crate::WString, n);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```wchar_t& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::cpp_core::wchar_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_at1(self as *mut crate::WString, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```wchar_t& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::cpp_core::wchar_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_back(self as *mut crate::WString);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const wchar_t& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::cpp_core::wchar_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_back1(self as *const crate::WString);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const wchar_t* std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::c_str() const```</span>.
    pub unsafe fn c_str(&self) -> ::cpp_core::Ptr<::cpp_core::wchar_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_c_str(self as *const crate::WString);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_capacity(self as *const crate::WString)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_clear(self as *mut crate::WString)
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::compare(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str) const```</span>.
    pub unsafe fn compare_w_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_compare(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::compare(size_t __pos, size_t __n, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str) const```</span>.
    pub unsafe fn compare_2_usize_w_string(
        &self,
        pos: usize,
        n: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_compare1(self as *const crate::WString, pos, n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::compare(size_t __pos1, size_t __n1, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos2, size_t __n2 = …) const```</span>.
    pub unsafe fn compare_2_usize_w_string2_usize(
        &self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos2: usize,
        n2: usize,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_compare2(self as *const crate::WString, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos2, n2)
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::compare(const wchar_t* __s) const```</span>.
    pub unsafe fn compare_wchar_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_compare3(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::compare(size_t __pos, size_t __n1, const wchar_t* __s) const```</span>.
    pub unsafe fn compare_2_usize_wchar_t(
        &self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_compare4(self as *const crate::WString, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::compare(size_t __pos, size_t __n1, const wchar_t* __s, size_t __n2) const```</span>.
    pub unsafe fn compare_2_usize_wchar_t_usize(
        &self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        n2: usize,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_compare5(self as *const crate::WString, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), n2)
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::compare(size_t __pos1, size_t __n1, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos2) const```</span>.
    pub unsafe fn compare_2_usize_w_string_usize(
        &self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos2: usize,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_compare6(self as *const crate::WString, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos2)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::copy(wchar_t* __s, size_t __n, size_t __pos = …) const```</span>.
    pub unsafe fn copy_3a(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::MutPtr<::cpp_core::wchar_t>>,
        n: usize,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_copy(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::MutPtr<::cpp_core::wchar_t>>::cast_into(s).as_mut_raw_ptr(), n, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::copy(wchar_t* __s, size_t __n) const```</span>.
    pub unsafe fn copy_2a(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::MutPtr<::cpp_core::wchar_t>>,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_copy1(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::MutPtr<::cpp_core::wchar_t>>::cast_into(s).as_mut_raw_ptr(), n)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::operator=(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str)```</span>.
    pub unsafe fn copy_from_w_string(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_operator_(self as *mut crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::operator=(const wchar_t* __s)```</span>.
    pub unsafe fn copy_from_wchar_t(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_operator_1(self as *mut crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::operator=(wchar_t __c)```</span>.
    pub unsafe fn copy_from_wchar_t2(
        &mut self,
        c: ::cpp_core::wchar_t,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_operator_2(self as *mut crate::WString, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const wchar_t* std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::cpp_core::wchar_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_data(self as *const crate::WString);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_empty(self as *const crate::WString)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::erase(size_t __pos = …, size_t __n = …)```</span>.
    pub unsafe fn erase_2a(&mut self, pos: usize, n: usize) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_erase(self as *mut crate::WString, pos, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::erase(size_t __pos = …)```</span>.
    pub unsafe fn erase_1a(&mut self, pos: usize) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_erase1(self as *mut crate::WString, pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::erase()```</span>.
    pub unsafe fn erase_0a(&mut self) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_erase2(self as *mut crate::WString);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find(const wchar_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_wchar_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_w_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find1(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find(const wchar_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_wchar_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find2(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find(wchar_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_wchar_t_usize2(&self, c: ::cpp_core::wchar_t, pos: usize) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find3(self as *const crate::WString, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str) const```</span>.
    pub unsafe fn find_w_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find4(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find(const wchar_t* __s) const```</span>.
    pub unsafe fn find_wchar_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find5(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find(wchar_t __c) const```</span>.
    pub unsafe fn find_wchar_t2(&self, c: ::cpp_core::wchar_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find6(self as *const crate::WString, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_not_of(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_not_of_w_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_first_not_of(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_not_of(const wchar_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_first_not_of_wchar_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_first_not_of1(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_not_of(const wchar_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_not_of_wchar_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_first_not_of2(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_not_of(wchar_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_not_of_wchar_t_usize2(
        &self,
        c: ::cpp_core::wchar_t,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_first_not_of3(self as *const crate::WString, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_not_of(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str) const```</span>.
    pub unsafe fn find_first_not_of_w_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_first_not_of4(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_not_of(const wchar_t* __s) const```</span>.
    pub unsafe fn find_first_not_of_wchar_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_first_not_of5(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_not_of(wchar_t __c) const```</span>.
    pub unsafe fn find_first_not_of_wchar_t2(&self, c: ::cpp_core::wchar_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_first_not_of6(self as *const crate::WString, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_of(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_of_w_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_first_of(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_of(const wchar_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_first_of_wchar_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_first_of1(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_of(const wchar_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_of_wchar_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_first_of2(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_of(wchar_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_of_wchar_t_usize2(&self, c: ::cpp_core::wchar_t, pos: usize) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_first_of3(self as *const crate::WString, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_of(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str) const```</span>.
    pub unsafe fn find_first_of_w_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_first_of4(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_of(const wchar_t* __s) const```</span>.
    pub unsafe fn find_first_of_wchar_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_first_of5(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_of(wchar_t __c) const```</span>.
    pub unsafe fn find_first_of_wchar_t2(&self, c: ::cpp_core::wchar_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_first_of6(self as *const crate::WString, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_not_of(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_not_of_w_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_last_not_of(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_not_of(const wchar_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_last_not_of_wchar_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_last_not_of1(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_not_of(const wchar_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_not_of_wchar_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_last_not_of2(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_not_of(wchar_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_not_of_wchar_t_usize2(
        &self,
        c: ::cpp_core::wchar_t,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_last_not_of3(self as *const crate::WString, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_not_of(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str) const```</span>.
    pub unsafe fn find_last_not_of_w_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_last_not_of4(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_not_of(const wchar_t* __s) const```</span>.
    pub unsafe fn find_last_not_of_wchar_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_last_not_of5(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_not_of(wchar_t __c) const```</span>.
    pub unsafe fn find_last_not_of_wchar_t2(&self, c: ::cpp_core::wchar_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_last_not_of6(self as *const crate::WString, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_of(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_of_w_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_last_of(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_of(const wchar_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_last_of_wchar_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_last_of1(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_of(const wchar_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_of_wchar_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_last_of2(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_of(wchar_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_of_wchar_t_usize2(&self, c: ::cpp_core::wchar_t, pos: usize) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_last_of3(self as *const crate::WString, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_of(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str) const```</span>.
    pub unsafe fn find_last_of_w_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_last_of4(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_of(const wchar_t* __s) const```</span>.
    pub unsafe fn find_last_of_wchar_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_last_of5(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_of(wchar_t __c) const```</span>.
    pub unsafe fn find_last_of_wchar_t2(&self, c: ::cpp_core::wchar_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_find_last_of6(self as *const crate::WString, c)
    }

    /// Calls C++ function: <span style='color: green;'>```wchar_t& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::cpp_core::wchar_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_front(self as *mut crate::WString);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const wchar_t& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::cpp_core::wchar_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_front1(self as *const crate::WString);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const wchar_t& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::operator[](size_t __pos) const```</span>.
    pub unsafe fn index(&self, pos: usize) -> ::cpp_core::Ref<::cpp_core::wchar_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_operator__(self as *const crate::WString, pos);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```wchar_t& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::operator[](size_t __pos)```</span>.
    pub unsafe fn index_mut(&mut self, pos: usize) -> ::cpp_core::MutRef<::cpp_core::wchar_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_operator__1(self as *mut crate::WString, pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::insert(size_t __pos1, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str)```</span>.
    pub unsafe fn insert_usize_w_string(
        &mut self,
        pos1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_insert(self as *mut crate::WString, pos1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::insert(size_t __pos1, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos2, size_t __n = …)```</span>.
    pub unsafe fn insert_usize_w_string2_usize(
        &mut self,
        pos1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos2: usize,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_insert1(self as *mut crate::WString, pos1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos2, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::insert(size_t __pos, const wchar_t* __s, size_t __n)```</span>.
    pub unsafe fn insert_usize_wchar_t_usize(
        &mut self,
        pos: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_insert2(self as *mut crate::WString, pos, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::insert(size_t __pos, const wchar_t* __s)```</span>.
    pub unsafe fn insert_usize_wchar_t(
        &mut self,
        pos: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_insert3(self as *mut crate::WString, pos, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::insert(size_t __pos, size_t __n, wchar_t __c)```</span>.
    pub unsafe fn insert_2_usize_wchar_t(
        &mut self,
        pos: usize,
        n: usize,
        c: ::cpp_core::wchar_t,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_insert4(self as *mut crate::WString, pos, n, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::insert(size_t __pos1, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos2)```</span>.
    pub unsafe fn insert_usize_w_string_usize(
        &mut self,
        pos1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos2: usize,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_insert5(self as *mut crate::WString, pos1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::length() const```</span>.
    pub unsafe fn length(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_length(self as *const crate::WString)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_max_size(self as *const crate::WString)
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::basic_string()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_basic_string();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::basic_string(const std::allocator<wchar_t>& __a)```</span>.
    pub unsafe fn from_allocator_of_wchar_t(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfWcharT>>,
    ) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_basic_string1(::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfWcharT>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::basic_string(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos, const std::allocator<wchar_t>& __a = …)```</span>.
    pub unsafe fn from_w_string_usize_allocator_of_wchar_t(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfWcharT>>,
    ) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_basic_string3(::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfWcharT>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::basic_string(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos, size_t __n)```</span>.
    pub unsafe fn from_w_string2_usize(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos: usize,
        n: usize,
    ) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_basic_string4(::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos, n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::basic_string(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos, size_t __n, const std::allocator<wchar_t>& __a)```</span>.
    pub unsafe fn from_w_string2_usize_allocator_of_wchar_t(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos: usize,
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfWcharT>>,
    ) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_basic_string5(::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos, n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfWcharT>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::basic_string(const wchar_t* __s, size_t __n, const std::allocator<wchar_t>& __a = …)```</span>.
    pub unsafe fn from_wchar_t_usize_allocator_of_wchar_t(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfWcharT>>,
    ) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_basic_string6(::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfWcharT>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::basic_string(const wchar_t* __s, const std::allocator<wchar_t>& __a = …)```</span>.
    pub unsafe fn from_wchar_t_allocator_of_wchar_t(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfWcharT>>,
    ) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_basic_string7(::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfWcharT>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::basic_string(size_t __n, wchar_t __c, const std::allocator<wchar_t>& __a = …)```</span>.
    pub unsafe fn from_usize_wchar_t_allocator_of_wchar_t(
        n: usize,
        c: ::cpp_core::wchar_t,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfWcharT>>,
    ) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_basic_string8(n, c, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfWcharT>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::basic_string(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, const std::allocator<wchar_t>& __a)```</span>.
    pub unsafe fn from_w_string_allocator_of_wchar_t(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfWcharT>>,
    ) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_basic_string10(::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfWcharT>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::basic_string(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos)```</span>.
    pub unsafe fn from_w_string_usize(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos: usize,
    ) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_basic_string12(::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::basic_string(const wchar_t* __s, size_t __n)```</span>.
    pub unsafe fn from_wchar_t_usize(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        n: usize,
    ) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_basic_string13(::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::basic_string(const wchar_t* __s)```</span>.
    pub unsafe fn from_wchar_t(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_basic_string14(::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::basic_string(size_t __n, wchar_t __c)```</span>.
    pub unsafe fn from_usize_wchar_t(
        n: usize,
        c: ::cpp_core::wchar_t,
    ) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_basic_string15(n, c);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::basic_string(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str)```</span>.
    pub unsafe fn new_copy(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    ) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_basic_string2(::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_pop_back(self as *mut crate::WString)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::push_back(wchar_t __c)```</span>.
    pub unsafe fn push_back(&mut self, c: ::cpp_core::wchar_t) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_push_back(self as *mut crate::WString, c)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::replace(size_t __pos, size_t __n, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str)```</span>.
    pub unsafe fn replace_2_usize_w_string(
        &mut self,
        pos: usize,
        n: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_replace(self as *mut crate::WString, pos, n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::replace(size_t __pos1, size_t __n1, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos2, size_t __n2 = …)```</span>.
    pub unsafe fn replace_2_usize_w_string2_usize(
        &mut self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos2: usize,
        n2: usize,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_replace1(self as *mut crate::WString, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos2, n2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::replace(size_t __pos, size_t __n1, const wchar_t* __s, size_t __n2)```</span>.
    pub unsafe fn replace_2_usize_wchar_t_usize(
        &mut self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        n2: usize,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_replace2(self as *mut crate::WString, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), n2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::replace(size_t __pos, size_t __n1, const wchar_t* __s)```</span>.
    pub unsafe fn replace_2_usize_wchar_t(
        &mut self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_replace3(self as *mut crate::WString, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::replace(size_t __pos, size_t __n1, size_t __n2, wchar_t __c)```</span>.
    pub unsafe fn replace_3_usize_wchar_t(
        &mut self,
        pos: usize,
        n1: usize,
        n2: usize,
        c: ::cpp_core::wchar_t,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_replace4(self as *mut crate::WString, pos, n1, n2, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::replace(size_t __pos1, size_t __n1, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos2)```</span>.
    pub unsafe fn replace_2_usize_w_string_usize(
        &mut self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos2: usize,
    ) -> ::cpp_core::MutRef<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_replace5(self as *mut crate::WString, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::reserve(size_t __res_arg = …)```</span>.
    pub unsafe fn reserve_1a(&mut self, res_arg: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_reserve(self as *mut crate::WString, res_arg)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::reserve()```</span>.
    pub unsafe fn reserve_0a(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_reserve1(self as *mut crate::WString)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::resize(size_t __n, wchar_t __c)```</span>.
    pub unsafe fn resize_2a(&mut self, n: usize, c: ::cpp_core::wchar_t) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_resize(self as *mut crate::WString, n, c)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::resize(size_t __n)```</span>.
    pub unsafe fn resize_1a(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_resize1(self as *mut crate::WString, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::rfind(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn rfind_w_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_rfind(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::rfind(const wchar_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn rfind_wchar_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_rfind1(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::rfind(const wchar_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn rfind_wchar_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_rfind2(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::rfind(wchar_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn rfind_wchar_t_usize2(&self, c: ::cpp_core::wchar_t, pos: usize) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_rfind3(self as *const crate::WString, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::rfind(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str) const```</span>.
    pub unsafe fn rfind_w_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_rfind4(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::rfind(const wchar_t* __s) const```</span>.
    pub unsafe fn rfind_wchar_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_rfind5(self as *const crate::WString, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::rfind(wchar_t __c) const```</span>.
    pub unsafe fn rfind_wchar_t2(&self, c: ::cpp_core::wchar_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_rfind6(self as *const crate::WString, c)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_shrink_to_fit(self as *mut crate::WString)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_size(self as *const crate::WString)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::substr(size_t __pos = …, size_t __n = …) const```</span>.
    pub unsafe fn substr_2a(&self, pos: usize, n: usize) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_substr(self as *const crate::WString, pos, n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::substr(size_t __pos = …) const```</span>.
    pub unsafe fn substr_1a(&self, pos: usize) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_substr1(self as *const crate::WString, pos);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::substr() const```</span>.
    pub unsafe fn substr_0a(&self) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_substr2(self as *const crate::WString);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::swap(std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __s)```</span>.
    pub unsafe fn swap(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::WString>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_swap(self as *mut crate::WString, ::cpp_core::CastInto::<::cpp_core::MutRef<crate::WString>>::cast_into(s).as_mut_raw_ptr())
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<wchar_t>```</span>.
#[repr(C)]
pub struct AllocatorOfWcharT {
    _unused: u8,
}
impl AllocatorOfWcharT {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<wchar_t>& std::allocator<wchar_t>::operator=(const std::allocator<wchar_t>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfWcharT>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfWcharT> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_wchar_t_operator_(
            self as *mut crate::AllocatorOfWcharT,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfWcharT>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<wchar_t>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfWcharT> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_wchar_t_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<wchar_t>::allocator(const std::allocator<wchar_t>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfWcharT>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfWcharT> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_wchar_t_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfWcharT>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>```</span>.
#[repr(C)]
pub struct U16String {
    _unused: u8,
}
impl U16String {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::append(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str)```</span>.
    pub unsafe fn append_u16_string(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_append(self as *mut crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::append(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos, size_t __n = …)```</span>.
    pub unsafe fn append_u16_string2_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos: usize,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_append1(self as *mut crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::append(const char16_t* __s, size_t __n)```</span>.
    pub unsafe fn append_char16_t_usize(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_append2(self as *mut crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::append(const char16_t* __s)```</span>.
    pub unsafe fn append_char16_t(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_append3(self as *mut crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::append(size_t __n, char16_t __c)```</span>.
    pub unsafe fn append_usize_char16_t(
        &mut self,
        n: usize,
        c: ::cpp_core::char16_t,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_append4(self as *mut crate::U16String, n, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::append(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos)```</span>.
    pub unsafe fn append_u16_string_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos: usize,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_append5(self as *mut crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::assign(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str)```</span>.
    pub unsafe fn assign_u16_string(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_assign(self as *mut crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::assign(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos, size_t __n = …)```</span>.
    pub unsafe fn assign_u16_string2_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos: usize,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_assign2(self as *mut crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::assign(const char16_t* __s, size_t __n)```</span>.
    pub unsafe fn assign_char16_t_usize(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_assign3(self as *mut crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::assign(const char16_t* __s)```</span>.
    pub unsafe fn assign_char16_t(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_assign4(self as *mut crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::assign(size_t __n, char16_t __c)```</span>.
    pub unsafe fn assign_usize_char16_t(
        &mut self,
        n: usize,
        c: ::cpp_core::char16_t,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_assign5(self as *mut crate::U16String, n, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::assign(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos)```</span>.
    pub unsafe fn assign_u16_string_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos: usize,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_assign6(self as *mut crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char16_t& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::cpp_core::char16_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_at(self as *const crate::U16String, n);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char16_t& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::cpp_core::char16_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_at1(self as *mut crate::U16String, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char16_t& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::cpp_core::char16_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_back(self as *mut crate::U16String);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char16_t& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::cpp_core::char16_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_back1(self as *const crate::U16String);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char16_t* std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::c_str() const```</span>.
    pub unsafe fn c_str(&self) -> ::cpp_core::Ptr<::cpp_core::char16_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_c_str(self as *const crate::U16String);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_capacity(self as *const crate::U16String)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_clear(self as *mut crate::U16String)
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::compare(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str) const```</span>.
    pub unsafe fn compare_u16_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_compare(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::compare(size_t __pos, size_t __n, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str) const```</span>.
    pub unsafe fn compare_2_usize_u16_string(
        &self,
        pos: usize,
        n: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_compare1(self as *const crate::U16String, pos, n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::compare(size_t __pos1, size_t __n1, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos2, size_t __n2 = …) const```</span>.
    pub unsafe fn compare_2_usize_u16_string2_usize(
        &self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos2: usize,
        n2: usize,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_compare2(self as *const crate::U16String, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos2, n2)
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::compare(const char16_t* __s) const```</span>.
    pub unsafe fn compare_char16_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_compare3(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::compare(size_t __pos, size_t __n1, const char16_t* __s) const```</span>.
    pub unsafe fn compare_2_usize_char16_t(
        &self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_compare4(self as *const crate::U16String, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::compare(size_t __pos, size_t __n1, const char16_t* __s, size_t __n2) const```</span>.
    pub unsafe fn compare_2_usize_char16_t_usize(
        &self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        n2: usize,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_compare5(self as *const crate::U16String, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), n2)
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::compare(size_t __pos1, size_t __n1, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos2) const```</span>.
    pub unsafe fn compare_2_usize_u16_string_usize(
        &self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos2: usize,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_compare6(self as *const crate::U16String, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos2)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::copy(char16_t* __s, size_t __n, size_t __pos = …) const```</span>.
    pub unsafe fn copy_3a(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::MutPtr<::cpp_core::char16_t>>,
        n: usize,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_copy(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::MutPtr<::cpp_core::char16_t>>::cast_into(s).as_mut_raw_ptr(), n, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::copy(char16_t* __s, size_t __n) const```</span>.
    pub unsafe fn copy_2a(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::MutPtr<::cpp_core::char16_t>>,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_copy1(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::MutPtr<::cpp_core::char16_t>>::cast_into(s).as_mut_raw_ptr(), n)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::operator=(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str)```</span>.
    pub unsafe fn copy_from_u16_string(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_operator_(self as *mut crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::operator=(const char16_t* __s)```</span>.
    pub unsafe fn copy_from_char16_t(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_operator_1(self as *mut crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::operator=(char16_t __c)```</span>.
    pub unsafe fn copy_from_char16_t2(
        &mut self,
        c: ::cpp_core::char16_t,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_operator_2(self as *mut crate::U16String, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char16_t* std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::cpp_core::char16_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_data(self as *const crate::U16String);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_empty(self as *const crate::U16String)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::erase(size_t __pos = …, size_t __n = …)```</span>.
    pub unsafe fn erase_2a(
        &mut self,
        pos: usize,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_erase(self as *mut crate::U16String, pos, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::erase(size_t __pos = …)```</span>.
    pub unsafe fn erase_1a(&mut self, pos: usize) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_erase1(self as *mut crate::U16String, pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::erase()```</span>.
    pub unsafe fn erase_0a(&mut self) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_erase2(self as *mut crate::U16String);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find(const char16_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_char16_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_u16_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find1(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find(const char16_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_char16_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find2(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find(char16_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_char16_t_usize2(&self, c: ::cpp_core::char16_t, pos: usize) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find3(self as *const crate::U16String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str) const```</span>.
    pub unsafe fn find_u16_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find4(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find(const char16_t* __s) const```</span>.
    pub unsafe fn find_char16_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find5(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find(char16_t __c) const```</span>.
    pub unsafe fn find_char16_t2(&self, c: ::cpp_core::char16_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find6(self as *const crate::U16String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_first_not_of(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_not_of_u16_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_first_not_of(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_first_not_of(const char16_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_first_not_of_char16_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_first_not_of1(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_first_not_of(const char16_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_not_of_char16_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_first_not_of2(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_first_not_of(char16_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_not_of_char16_t_usize2(
        &self,
        c: ::cpp_core::char16_t,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_first_not_of3(self as *const crate::U16String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_first_not_of(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str) const```</span>.
    pub unsafe fn find_first_not_of_u16_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_first_not_of4(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_first_not_of(const char16_t* __s) const```</span>.
    pub unsafe fn find_first_not_of_char16_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_first_not_of5(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_first_not_of(char16_t __c) const```</span>.
    pub unsafe fn find_first_not_of_char16_t2(&self, c: ::cpp_core::char16_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_first_not_of6(self as *const crate::U16String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_first_of(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_of_u16_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_first_of(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_first_of(const char16_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_first_of_char16_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_first_of1(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_first_of(const char16_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_of_char16_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_first_of2(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_first_of(char16_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_of_char16_t_usize2(
        &self,
        c: ::cpp_core::char16_t,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_first_of3(self as *const crate::U16String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_first_of(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str) const```</span>.
    pub unsafe fn find_first_of_u16_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_first_of4(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_first_of(const char16_t* __s) const```</span>.
    pub unsafe fn find_first_of_char16_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_first_of5(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_first_of(char16_t __c) const```</span>.
    pub unsafe fn find_first_of_char16_t2(&self, c: ::cpp_core::char16_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_first_of6(self as *const crate::U16String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_last_not_of(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_not_of_u16_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_last_not_of(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_last_not_of(const char16_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_last_not_of_char16_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_last_not_of1(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_last_not_of(const char16_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_not_of_char16_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_last_not_of2(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_last_not_of(char16_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_not_of_char16_t_usize2(
        &self,
        c: ::cpp_core::char16_t,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_last_not_of3(self as *const crate::U16String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_last_not_of(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str) const```</span>.
    pub unsafe fn find_last_not_of_u16_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_last_not_of4(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_last_not_of(const char16_t* __s) const```</span>.
    pub unsafe fn find_last_not_of_char16_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_last_not_of5(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_last_not_of(char16_t __c) const```</span>.
    pub unsafe fn find_last_not_of_char16_t2(&self, c: ::cpp_core::char16_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_last_not_of6(self as *const crate::U16String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_last_of(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_of_u16_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_last_of(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_last_of(const char16_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_last_of_char16_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_last_of1(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_last_of(const char16_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_of_char16_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_last_of2(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_last_of(char16_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_of_char16_t_usize2(
        &self,
        c: ::cpp_core::char16_t,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_last_of3(self as *const crate::U16String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_last_of(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str) const```</span>.
    pub unsafe fn find_last_of_u16_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_last_of4(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_last_of(const char16_t* __s) const```</span>.
    pub unsafe fn find_last_of_char16_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_last_of5(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::find_last_of(char16_t __c) const```</span>.
    pub unsafe fn find_last_of_char16_t2(&self, c: ::cpp_core::char16_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_find_last_of6(self as *const crate::U16String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```char16_t& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::cpp_core::char16_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_front(self as *mut crate::U16String);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char16_t& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::cpp_core::char16_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_front1(self as *const crate::U16String);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char16_t& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::operator[](size_t __pos) const```</span>.
    pub unsafe fn index(&self, pos: usize) -> ::cpp_core::Ref<::cpp_core::char16_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_operator__(self as *const crate::U16String, pos);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char16_t& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::operator[](size_t __pos)```</span>.
    pub unsafe fn index_mut(&mut self, pos: usize) -> ::cpp_core::MutRef<::cpp_core::char16_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_operator__1(self as *mut crate::U16String, pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::insert(size_t __pos1, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str)```</span>.
    pub unsafe fn insert_usize_u16_string(
        &mut self,
        pos1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_insert(self as *mut crate::U16String, pos1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::insert(size_t __pos1, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos2, size_t __n = …)```</span>.
    pub unsafe fn insert_usize_u16_string2_usize(
        &mut self,
        pos1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos2: usize,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_insert1(self as *mut crate::U16String, pos1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos2, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::insert(size_t __pos, const char16_t* __s, size_t __n)```</span>.
    pub unsafe fn insert_usize_char16_t_usize(
        &mut self,
        pos: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_insert2(self as *mut crate::U16String, pos, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::insert(size_t __pos, const char16_t* __s)```</span>.
    pub unsafe fn insert_usize_char16_t(
        &mut self,
        pos: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_insert3(self as *mut crate::U16String, pos, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::insert(size_t __pos, size_t __n, char16_t __c)```</span>.
    pub unsafe fn insert_2_usize_char16_t(
        &mut self,
        pos: usize,
        n: usize,
        c: ::cpp_core::char16_t,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_insert4(self as *mut crate::U16String, pos, n, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::insert(size_t __pos1, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos2)```</span>.
    pub unsafe fn insert_usize_u16_string_usize(
        &mut self,
        pos1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos2: usize,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_insert5(self as *mut crate::U16String, pos1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::length() const```</span>.
    pub unsafe fn length(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_length(self as *const crate::U16String)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_max_size(self as *const crate::U16String)
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::basic_string()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_basic_string();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::basic_string(const std::allocator<char16_t>& __a)```</span>.
    pub unsafe fn from_allocator_of_char16_t(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar16T>>,
    ) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_basic_string1(::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar16T>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::basic_string(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos, const std::allocator<char16_t>& __a = …)```</span>.
    pub unsafe fn from_u16_string_usize_allocator_of_char16_t(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar16T>>,
    ) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_basic_string3(::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar16T>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::basic_string(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos, size_t __n)```</span>.
    pub unsafe fn from_u16_string2_usize(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos: usize,
        n: usize,
    ) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_basic_string4(::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos, n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::basic_string(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos, size_t __n, const std::allocator<char16_t>& __a)```</span>.
    pub unsafe fn from_u16_string2_usize_allocator_of_char16_t(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos: usize,
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar16T>>,
    ) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_basic_string5(::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos, n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar16T>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::basic_string(const char16_t* __s, size_t __n, const std::allocator<char16_t>& __a = …)```</span>.
    pub unsafe fn from_char16_t_usize_allocator_of_char16_t(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar16T>>,
    ) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_basic_string6(::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar16T>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::basic_string(const char16_t* __s, const std::allocator<char16_t>& __a = …)```</span>.
    pub unsafe fn from_char16_t_allocator_of_char16_t(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar16T>>,
    ) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_basic_string7(::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar16T>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::basic_string(size_t __n, char16_t __c, const std::allocator<char16_t>& __a = …)```</span>.
    pub unsafe fn from_usize_char16_t_allocator_of_char16_t(
        n: usize,
        c: ::cpp_core::char16_t,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar16T>>,
    ) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_basic_string8(n, c, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar16T>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::basic_string(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, const std::allocator<char16_t>& __a)```</span>.
    pub unsafe fn from_u16_string_allocator_of_char16_t(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar16T>>,
    ) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_basic_string10(::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar16T>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::basic_string(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos)```</span>.
    pub unsafe fn from_u16_string_usize(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos: usize,
    ) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_basic_string12(::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::basic_string(const char16_t* __s, size_t __n)```</span>.
    pub unsafe fn from_char16_t_usize(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        n: usize,
    ) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_basic_string13(::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::basic_string(const char16_t* __s)```</span>.
    pub unsafe fn from_char16_t(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_basic_string14(::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::basic_string(size_t __n, char16_t __c)```</span>.
    pub unsafe fn from_usize_char16_t(
        n: usize,
        c: ::cpp_core::char16_t,
    ) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_basic_string15(n, c);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::basic_string(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str)```</span>.
    pub unsafe fn new_copy(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
    ) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_basic_string2(::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_pop_back(self as *mut crate::U16String)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::push_back(char16_t __c)```</span>.
    pub unsafe fn push_back(&mut self, c: ::cpp_core::char16_t) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_push_back(self as *mut crate::U16String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::replace(size_t __pos, size_t __n, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str)```</span>.
    pub unsafe fn replace_2_usize_u16_string(
        &mut self,
        pos: usize,
        n: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_replace(self as *mut crate::U16String, pos, n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::replace(size_t __pos1, size_t __n1, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos2, size_t __n2 = …)```</span>.
    pub unsafe fn replace_2_usize_u16_string2_usize(
        &mut self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos2: usize,
        n2: usize,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_replace1(self as *mut crate::U16String, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos2, n2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::replace(size_t __pos, size_t __n1, const char16_t* __s, size_t __n2)```</span>.
    pub unsafe fn replace_2_usize_char16_t_usize(
        &mut self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        n2: usize,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_replace2(self as *mut crate::U16String, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), n2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::replace(size_t __pos, size_t __n1, const char16_t* __s)```</span>.
    pub unsafe fn replace_2_usize_char16_t(
        &mut self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_replace3(self as *mut crate::U16String, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::replace(size_t __pos, size_t __n1, size_t __n2, char16_t __c)```</span>.
    pub unsafe fn replace_3_usize_char16_t(
        &mut self,
        pos: usize,
        n1: usize,
        n2: usize,
        c: ::cpp_core::char16_t,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_replace4(self as *mut crate::U16String, pos, n1, n2, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::replace(size_t __pos1, size_t __n1, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos2)```</span>.
    pub unsafe fn replace_2_usize_u16_string_usize(
        &mut self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos2: usize,
    ) -> ::cpp_core::MutRef<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_replace5(self as *mut crate::U16String, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::reserve(size_t __res_arg = …)```</span>.
    pub unsafe fn reserve_1a(&mut self, res_arg: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_reserve(self as *mut crate::U16String, res_arg)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::reserve()```</span>.
    pub unsafe fn reserve_0a(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_reserve1(self as *mut crate::U16String)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::resize(size_t __n, char16_t __c)```</span>.
    pub unsafe fn resize_2a(&mut self, n: usize, c: ::cpp_core::char16_t) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_resize(self as *mut crate::U16String, n, c)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::resize(size_t __n)```</span>.
    pub unsafe fn resize_1a(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_resize1(self as *mut crate::U16String, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::rfind(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn rfind_u16_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_rfind(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::rfind(const char16_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn rfind_char16_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_rfind1(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::rfind(const char16_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn rfind_char16_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_rfind2(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::rfind(char16_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn rfind_char16_t_usize2(&self, c: ::cpp_core::char16_t, pos: usize) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_rfind3(self as *const crate::U16String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::rfind(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str) const```</span>.
    pub unsafe fn rfind_u16_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_rfind4(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::rfind(const char16_t* __s) const```</span>.
    pub unsafe fn rfind_char16_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_rfind5(self as *const crate::U16String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::rfind(char16_t __c) const```</span>.
    pub unsafe fn rfind_char16_t2(&self, c: ::cpp_core::char16_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_rfind6(self as *const crate::U16String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_shrink_to_fit(self as *mut crate::U16String)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_size(self as *const crate::U16String)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>> std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::substr(size_t __pos = …, size_t __n = …) const```</span>.
    pub unsafe fn substr_2a(&self, pos: usize, n: usize) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_substr(self as *const crate::U16String, pos, n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>> std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::substr(size_t __pos = …) const```</span>.
    pub unsafe fn substr_1a(&self, pos: usize) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_substr1(self as *const crate::U16String, pos);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>> std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::substr() const```</span>.
    pub unsafe fn substr_0a(&self) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_substr2(self as *const crate::U16String);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::swap(std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __s)```</span>.
    pub unsafe fn swap(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::U16String>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_swap(self as *mut crate::U16String, ::cpp_core::CastInto::<::cpp_core::MutRef<crate::U16String>>::cast_into(s).as_mut_raw_ptr())
    }
}

/// C++ class: <span style='color: green;'>```std::char_traits<char16_t>```</span>.
#[repr(C)]
pub struct CharTraitsOfChar16T {
    _unused: u8,
}
impl CharTraitsOfChar16T {
    /// Calls C++ function: <span style='color: green;'>```std::char_traits<char16_t>& std::char_traits<char16_t>::operator=(const std::char_traits<char16_t>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::CharTraitsOfChar16T>>,
    ) -> ::cpp_core::MutRef<crate::CharTraitsOfChar16T> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_char_traits_char16_t_operator_(
            self as *mut crate::CharTraitsOfChar16T,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::CharTraitsOfChar16T>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::char_traits<char16_t>::char_traits()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::CharTraitsOfChar16T> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_char_traits_char16_t_char_traits();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::char_traits<char16_t>::char_traits(const std::char_traits<char16_t>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::CharTraitsOfChar16T>>,
    ) -> ::cpp_core::CppBox<crate::CharTraitsOfChar16T> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_char_traits_char16_t_char_traits1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::CharTraitsOfChar16T>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<char16_t>```</span>.
#[repr(C)]
pub struct AllocatorOfChar16T {
    _unused: u8,
}
impl AllocatorOfChar16T {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<char16_t>& std::allocator<char16_t>::operator=(const std::allocator<char16_t>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar16T>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfChar16T> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_char16_t_operator_(
            self as *mut crate::AllocatorOfChar16T,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar16T>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<char16_t>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfChar16T> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_char16_t_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<char16_t>::allocator(const std::allocator<char16_t>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar16T>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfChar16T> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_char16_t_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar16T>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>```</span>.
#[repr(C)]
pub struct U32String {
    _unused: u8,
}
impl U32String {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::append(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str)```</span>.
    pub unsafe fn append_u32_string(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_append(self as *mut crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::append(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos, size_t __n = …)```</span>.
    pub unsafe fn append_u32_string2_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos: usize,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_append1(self as *mut crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::append(const char32_t* __s, size_t __n)```</span>.
    pub unsafe fn append_char32_t_usize(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_append2(self as *mut crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::append(const char32_t* __s)```</span>.
    pub unsafe fn append_char32_t(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_append3(self as *mut crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::append(size_t __n, char32_t __c)```</span>.
    pub unsafe fn append_usize_char32_t(
        &mut self,
        n: usize,
        c: ::cpp_core::char32_t,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_append4(self as *mut crate::U32String, n, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::append(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos)```</span>.
    pub unsafe fn append_u32_string_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos: usize,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_append5(self as *mut crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::assign(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str)```</span>.
    pub unsafe fn assign_u32_string(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_assign(self as *mut crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::assign(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos, size_t __n = …)```</span>.
    pub unsafe fn assign_u32_string2_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos: usize,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_assign2(self as *mut crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::assign(const char32_t* __s, size_t __n)```</span>.
    pub unsafe fn assign_char32_t_usize(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_assign3(self as *mut crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::assign(const char32_t* __s)```</span>.
    pub unsafe fn assign_char32_t(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_assign4(self as *mut crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::assign(size_t __n, char32_t __c)```</span>.
    pub unsafe fn assign_usize_char32_t(
        &mut self,
        n: usize,
        c: ::cpp_core::char32_t,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_assign5(self as *mut crate::U32String, n, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::assign(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos)```</span>.
    pub unsafe fn assign_u32_string_usize(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos: usize,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_assign6(self as *mut crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char32_t& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::cpp_core::char32_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_at(self as *const crate::U32String, n);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char32_t& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::cpp_core::char32_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_at1(self as *mut crate::U32String, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char32_t& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::cpp_core::char32_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_back(self as *mut crate::U32String);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char32_t& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::cpp_core::char32_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_back1(self as *const crate::U32String);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char32_t* std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::c_str() const```</span>.
    pub unsafe fn c_str(&self) -> ::cpp_core::Ptr<::cpp_core::char32_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_c_str(self as *const crate::U32String);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_capacity(self as *const crate::U32String)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_clear(self as *mut crate::U32String)
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::compare(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str) const```</span>.
    pub unsafe fn compare_u32_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_compare(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::compare(size_t __pos, size_t __n, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str) const```</span>.
    pub unsafe fn compare_2_usize_u32_string(
        &self,
        pos: usize,
        n: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_compare1(self as *const crate::U32String, pos, n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::compare(size_t __pos1, size_t __n1, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos2, size_t __n2 = …) const```</span>.
    pub unsafe fn compare_2_usize_u32_string2_usize(
        &self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos2: usize,
        n2: usize,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_compare2(self as *const crate::U32String, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos2, n2)
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::compare(const char32_t* __s) const```</span>.
    pub unsafe fn compare_char32_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_compare3(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::compare(size_t __pos, size_t __n1, const char32_t* __s) const```</span>.
    pub unsafe fn compare_2_usize_char32_t(
        &self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_compare4(self as *const crate::U32String, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::compare(size_t __pos, size_t __n1, const char32_t* __s, size_t __n2) const```</span>.
    pub unsafe fn compare_2_usize_char32_t_usize(
        &self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        n2: usize,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_compare5(self as *const crate::U32String, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), n2)
    }

    /// Calls C++ function: <span style='color: green;'>```int std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::compare(size_t __pos1, size_t __n1, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos2) const```</span>.
    pub unsafe fn compare_2_usize_u32_string_usize(
        &self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos2: usize,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_compare6(self as *const crate::U32String, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos2)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::copy(char32_t* __s, size_t __n, size_t __pos = …) const```</span>.
    pub unsafe fn copy_3a(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::MutPtr<::cpp_core::char32_t>>,
        n: usize,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_copy(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::MutPtr<::cpp_core::char32_t>>::cast_into(s).as_mut_raw_ptr(), n, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::copy(char32_t* __s, size_t __n) const```</span>.
    pub unsafe fn copy_2a(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::MutPtr<::cpp_core::char32_t>>,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_copy1(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::MutPtr<::cpp_core::char32_t>>::cast_into(s).as_mut_raw_ptr(), n)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::operator=(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str)```</span>.
    pub unsafe fn copy_from_u32_string(
        &mut self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_operator_(self as *mut crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::operator=(const char32_t* __s)```</span>.
    pub unsafe fn copy_from_char32_t(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_operator_1(self as *mut crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::operator=(char32_t __c)```</span>.
    pub unsafe fn copy_from_char32_t2(
        &mut self,
        c: ::cpp_core::char32_t,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_operator_2(self as *mut crate::U32String, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char32_t* std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::cpp_core::char32_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_data(self as *const crate::U32String);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_empty(self as *const crate::U32String)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::erase(size_t __pos = …, size_t __n = …)```</span>.
    pub unsafe fn erase_2a(
        &mut self,
        pos: usize,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_erase(self as *mut crate::U32String, pos, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::erase(size_t __pos = …)```</span>.
    pub unsafe fn erase_1a(&mut self, pos: usize) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_erase1(self as *mut crate::U32String, pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::erase()```</span>.
    pub unsafe fn erase_0a(&mut self) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_erase2(self as *mut crate::U32String);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find(const char32_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_char32_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_u32_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find1(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find(const char32_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_char32_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find2(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find(char32_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_char32_t_usize2(&self, c: ::cpp_core::char32_t, pos: usize) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find3(self as *const crate::U32String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str) const```</span>.
    pub unsafe fn find_u32_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find4(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find(const char32_t* __s) const```</span>.
    pub unsafe fn find_char32_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find5(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find(char32_t __c) const```</span>.
    pub unsafe fn find_char32_t2(&self, c: ::cpp_core::char32_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find6(self as *const crate::U32String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_first_not_of(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_not_of_u32_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_first_not_of(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_first_not_of(const char32_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_first_not_of_char32_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_first_not_of1(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_first_not_of(const char32_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_not_of_char32_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_first_not_of2(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_first_not_of(char32_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_not_of_char32_t_usize2(
        &self,
        c: ::cpp_core::char32_t,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_first_not_of3(self as *const crate::U32String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_first_not_of(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str) const```</span>.
    pub unsafe fn find_first_not_of_u32_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_first_not_of4(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_first_not_of(const char32_t* __s) const```</span>.
    pub unsafe fn find_first_not_of_char32_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_first_not_of5(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_first_not_of(char32_t __c) const```</span>.
    pub unsafe fn find_first_not_of_char32_t2(&self, c: ::cpp_core::char32_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_first_not_of6(self as *const crate::U32String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_first_of(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_of_u32_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_first_of(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_first_of(const char32_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_first_of_char32_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_first_of1(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_first_of(const char32_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_of_char32_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_first_of2(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_first_of(char32_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_first_of_char32_t_usize2(
        &self,
        c: ::cpp_core::char32_t,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_first_of3(self as *const crate::U32String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_first_of(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str) const```</span>.
    pub unsafe fn find_first_of_u32_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_first_of4(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_first_of(const char32_t* __s) const```</span>.
    pub unsafe fn find_first_of_char32_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_first_of5(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_first_of(char32_t __c) const```</span>.
    pub unsafe fn find_first_of_char32_t2(&self, c: ::cpp_core::char32_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_first_of6(self as *const crate::U32String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_last_not_of(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_not_of_u32_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_last_not_of(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_last_not_of(const char32_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_last_not_of_char32_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_last_not_of1(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_last_not_of(const char32_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_not_of_char32_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_last_not_of2(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_last_not_of(char32_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_not_of_char32_t_usize2(
        &self,
        c: ::cpp_core::char32_t,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_last_not_of3(self as *const crate::U32String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_last_not_of(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str) const```</span>.
    pub unsafe fn find_last_not_of_u32_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_last_not_of4(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_last_not_of(const char32_t* __s) const```</span>.
    pub unsafe fn find_last_not_of_char32_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_last_not_of5(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_last_not_of(char32_t __c) const```</span>.
    pub unsafe fn find_last_not_of_char32_t2(&self, c: ::cpp_core::char32_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_last_not_of6(self as *const crate::U32String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_last_of(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_of_u32_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_last_of(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_last_of(const char32_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn find_last_of_char32_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_last_of1(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_last_of(const char32_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_of_char32_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_last_of2(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_last_of(char32_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn find_last_of_char32_t_usize2(
        &self,
        c: ::cpp_core::char32_t,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_last_of3(self as *const crate::U32String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_last_of(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str) const```</span>.
    pub unsafe fn find_last_of_u32_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_last_of4(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_last_of(const char32_t* __s) const```</span>.
    pub unsafe fn find_last_of_char32_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_last_of5(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::find_last_of(char32_t __c) const```</span>.
    pub unsafe fn find_last_of_char32_t2(&self, c: ::cpp_core::char32_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_find_last_of6(self as *const crate::U32String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```char32_t& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::cpp_core::char32_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_front(self as *mut crate::U32String);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char32_t& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::cpp_core::char32_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_front1(self as *const crate::U32String);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char32_t& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::operator[](size_t __pos) const```</span>.
    pub unsafe fn index(&self, pos: usize) -> ::cpp_core::Ref<::cpp_core::char32_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_operator__(self as *const crate::U32String, pos);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char32_t& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::operator[](size_t __pos)```</span>.
    pub unsafe fn index_mut(&mut self, pos: usize) -> ::cpp_core::MutRef<::cpp_core::char32_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_operator__1(self as *mut crate::U32String, pos);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::insert(size_t __pos1, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str)```</span>.
    pub unsafe fn insert_usize_u32_string(
        &mut self,
        pos1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_insert(self as *mut crate::U32String, pos1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::insert(size_t __pos1, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos2, size_t __n = …)```</span>.
    pub unsafe fn insert_usize_u32_string2_usize(
        &mut self,
        pos1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos2: usize,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_insert1(self as *mut crate::U32String, pos1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos2, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::insert(size_t __pos, const char32_t* __s, size_t __n)```</span>.
    pub unsafe fn insert_usize_char32_t_usize(
        &mut self,
        pos: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        n: usize,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_insert2(self as *mut crate::U32String, pos, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::insert(size_t __pos, const char32_t* __s)```</span>.
    pub unsafe fn insert_usize_char32_t(
        &mut self,
        pos: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_insert3(self as *mut crate::U32String, pos, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::insert(size_t __pos, size_t __n, char32_t __c)```</span>.
    pub unsafe fn insert_2_usize_char32_t(
        &mut self,
        pos: usize,
        n: usize,
        c: ::cpp_core::char32_t,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_insert4(self as *mut crate::U32String, pos, n, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::insert(size_t __pos1, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos2)```</span>.
    pub unsafe fn insert_usize_u32_string_usize(
        &mut self,
        pos1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos2: usize,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_insert5(self as *mut crate::U32String, pos1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::length() const```</span>.
    pub unsafe fn length(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_length(self as *const crate::U32String)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_max_size(self as *const crate::U32String)
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::basic_string()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_basic_string();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::basic_string(const std::allocator<char32_t>& __a)```</span>.
    pub unsafe fn from_allocator_of_char32_t(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar32T>>,
    ) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_basic_string1(::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar32T>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::basic_string(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos, const std::allocator<char32_t>& __a = …)```</span>.
    pub unsafe fn from_u32_string_usize_allocator_of_char32_t(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar32T>>,
    ) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_basic_string3(::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar32T>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::basic_string(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos, size_t __n)```</span>.
    pub unsafe fn from_u32_string2_usize(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos: usize,
        n: usize,
    ) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_basic_string4(::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos, n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::basic_string(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos, size_t __n, const std::allocator<char32_t>& __a)```</span>.
    pub unsafe fn from_u32_string2_usize_allocator_of_char32_t(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos: usize,
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar32T>>,
    ) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_basic_string5(::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos, n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar32T>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::basic_string(const char32_t* __s, size_t __n, const std::allocator<char32_t>& __a = …)```</span>.
    pub unsafe fn from_char32_t_usize_allocator_of_char32_t(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar32T>>,
    ) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_basic_string6(::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar32T>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::basic_string(const char32_t* __s, const std::allocator<char32_t>& __a = …)```</span>.
    pub unsafe fn from_char32_t_allocator_of_char32_t(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar32T>>,
    ) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_basic_string7(::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar32T>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::basic_string(size_t __n, char32_t __c, const std::allocator<char32_t>& __a = …)```</span>.
    pub unsafe fn from_usize_char32_t_allocator_of_char32_t(
        n: usize,
        c: ::cpp_core::char32_t,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar32T>>,
    ) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_basic_string8(n, c, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar32T>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::basic_string(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, const std::allocator<char32_t>& __a)```</span>.
    pub unsafe fn from_u32_string_allocator_of_char32_t(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar32T>>,
    ) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_basic_string10(::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar32T>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::basic_string(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos)```</span>.
    pub unsafe fn from_u32_string_usize(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos: usize,
    ) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_basic_string12(::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::basic_string(const char32_t* __s, size_t __n)```</span>.
    pub unsafe fn from_char32_t_usize(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        n: usize,
    ) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_basic_string13(::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::basic_string(const char32_t* __s)```</span>.
    pub unsafe fn from_char32_t(
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_basic_string14(::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::basic_string(size_t __n, char32_t __c)```</span>.
    pub unsafe fn from_usize_char32_t(
        n: usize,
        c: ::cpp_core::char32_t,
    ) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_basic_string15(n, c);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::basic_string(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str)```</span>.
    pub unsafe fn new_copy(
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
    ) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_basic_string2(::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_pop_back(self as *mut crate::U32String)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::push_back(char32_t __c)```</span>.
    pub unsafe fn push_back(&mut self, c: ::cpp_core::char32_t) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_push_back(self as *mut crate::U32String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::replace(size_t __pos, size_t __n, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str)```</span>.
    pub unsafe fn replace_2_usize_u32_string(
        &mut self,
        pos: usize,
        n: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_replace(self as *mut crate::U32String, pos, n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::replace(size_t __pos1, size_t __n1, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos2, size_t __n2 = …)```</span>.
    pub unsafe fn replace_2_usize_u32_string2_usize(
        &mut self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos2: usize,
        n2: usize,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_replace1(self as *mut crate::U32String, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos2, n2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::replace(size_t __pos, size_t __n1, const char32_t* __s, size_t __n2)```</span>.
    pub unsafe fn replace_2_usize_char32_t_usize(
        &mut self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        n2: usize,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_replace2(self as *mut crate::U32String, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), n2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::replace(size_t __pos, size_t __n1, const char32_t* __s)```</span>.
    pub unsafe fn replace_2_usize_char32_t(
        &mut self,
        pos: usize,
        n1: usize,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_replace3(self as *mut crate::U32String, pos, n1, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::replace(size_t __pos, size_t __n1, size_t __n2, char32_t __c)```</span>.
    pub unsafe fn replace_3_usize_char32_t(
        &mut self,
        pos: usize,
        n1: usize,
        n2: usize,
        c: ::cpp_core::char32_t,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_replace4(self as *mut crate::U32String, pos, n1, n2, c);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::replace(size_t __pos1, size_t __n1, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos2)```</span>.
    pub unsafe fn replace_2_usize_u32_string_usize(
        &mut self,
        pos1: usize,
        n1: usize,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos2: usize,
    ) -> ::cpp_core::MutRef<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_replace5(self as *mut crate::U32String, pos1, n1, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos2);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::reserve(size_t __res_arg = …)```</span>.
    pub unsafe fn reserve_1a(&mut self, res_arg: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_reserve(self as *mut crate::U32String, res_arg)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::reserve()```</span>.
    pub unsafe fn reserve_0a(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_reserve1(self as *mut crate::U32String)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::resize(size_t __n, char32_t __c)```</span>.
    pub unsafe fn resize_2a(&mut self, n: usize, c: ::cpp_core::char32_t) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_resize(self as *mut crate::U32String, n, c)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::resize(size_t __n)```</span>.
    pub unsafe fn resize_1a(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_resize1(self as *mut crate::U32String, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::rfind(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str, size_t __pos = …) const```</span>.
    pub unsafe fn rfind_u32_string_usize(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_rfind(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::rfind(const char32_t* __s, size_t __pos, size_t __n) const```</span>.
    pub unsafe fn rfind_char32_t2_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        pos: usize,
        n: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_rfind1(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), pos, n)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::rfind(const char32_t* __s, size_t __pos = …) const```</span>.
    pub unsafe fn rfind_char32_t_usize(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        pos: usize,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_rfind2(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr(), pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::rfind(char32_t __c, size_t __pos = …) const```</span>.
    pub unsafe fn rfind_char32_t_usize2(&self, c: ::cpp_core::char32_t, pos: usize) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_rfind3(self as *const crate::U32String, c, pos)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::rfind(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str) const```</span>.
    pub unsafe fn rfind_u32_string(
        &self,
        str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_rfind4(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(str).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::rfind(const char32_t* __s) const```</span>.
    pub unsafe fn rfind_char32_t(
        &self,
        s: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_rfind5(self as *const crate::U32String, ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(s).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::rfind(char32_t __c) const```</span>.
    pub unsafe fn rfind_char32_t2(&self, c: ::cpp_core::char32_t) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_rfind6(self as *const crate::U32String, c)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_shrink_to_fit(self as *mut crate::U32String)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_size(self as *const crate::U32String)
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>> std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::substr(size_t __pos = …, size_t __n = …) const```</span>.
    pub unsafe fn substr_2a(&self, pos: usize, n: usize) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_substr(self as *const crate::U32String, pos, n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>> std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::substr(size_t __pos = …) const```</span>.
    pub unsafe fn substr_1a(&self, pos: usize) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_substr1(self as *const crate::U32String, pos);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>> std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::substr() const```</span>.
    pub unsafe fn substr_0a(&self) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_substr2(self as *const crate::U32String);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::swap(std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __s)```</span>.
    pub unsafe fn swap(
        &mut self,
        s: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::U32String>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_swap(self as *mut crate::U32String, ::cpp_core::CastInto::<::cpp_core::MutRef<crate::U32String>>::cast_into(s).as_mut_raw_ptr())
    }
}

/// C++ class: <span style='color: green;'>```std::char_traits<char32_t>```</span>.
#[repr(C)]
pub struct CharTraitsOfChar32T {
    _unused: u8,
}
impl CharTraitsOfChar32T {
    /// Calls C++ function: <span style='color: green;'>```std::char_traits<char32_t>& std::char_traits<char32_t>::operator=(const std::char_traits<char32_t>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::CharTraitsOfChar32T>>,
    ) -> ::cpp_core::MutRef<crate::CharTraitsOfChar32T> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_char_traits_char32_t_operator_(
            self as *mut crate::CharTraitsOfChar32T,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::CharTraitsOfChar32T>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::char_traits<char32_t>::char_traits()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::CharTraitsOfChar32T> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_char_traits_char32_t_char_traits();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::char_traits<char32_t>::char_traits(const std::char_traits<char32_t>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::CharTraitsOfChar32T>>,
    ) -> ::cpp_core::CppBox<crate::CharTraitsOfChar32T> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_char_traits_char32_t_char_traits1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::CharTraitsOfChar32T>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<char32_t>```</span>.
#[repr(C)]
pub struct AllocatorOfChar32T {
    _unused: u8,
}
impl AllocatorOfChar32T {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<char32_t>& std::allocator<char32_t>::operator=(const std::allocator<char32_t>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar32T>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfChar32T> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_char32_t_operator_(
            self as *mut crate::AllocatorOfChar32T,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar32T>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<char32_t>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfChar32T> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_char32_t_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<char32_t>::allocator(const std::allocator<char32_t>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar32T>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfChar32T> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_char32_t_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar32T>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<bool>```</span>.
#[repr(C)]
pub struct AllocatorOfBool {
    _unused: u8,
}
impl AllocatorOfBool {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<bool>& std::allocator<bool>::operator=(const std::allocator<bool>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfBool>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfBool> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_bool_operator_(
            self as *mut crate::AllocatorOfBool,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfBool>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<bool>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfBool> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_bool_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<bool>::allocator(const std::allocator<bool>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfBool>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfBool> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_bool_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfBool>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<signed char>```</span>.
#[repr(C)]
pub struct AllocatorOfSchar {
    _unused: u8,
}
impl AllocatorOfSchar {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<signed char>& std::allocator<signed char>::operator=(const std::allocator<signed char>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfSchar>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfSchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_signed_char_operator_(
            self as *mut crate::AllocatorOfSchar,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfSchar>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<signed char>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfSchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_signed_char_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<signed char>::allocator(const std::allocator<signed char>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfSchar>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfSchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_signed_char_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfSchar>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<unsigned char>```</span>.
#[repr(C)]
pub struct AllocatorOfUchar {
    _unused: u8,
}
impl AllocatorOfUchar {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<unsigned char>& std::allocator<unsigned char>::operator=(const std::allocator<unsigned char>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUchar>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfUchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_char_operator_(
            self as *mut crate::AllocatorOfUchar,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUchar>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<unsigned char>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfUchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_char_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<unsigned char>::allocator(const std::allocator<unsigned char>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUchar>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfUchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_char_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUchar>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<short>```</span>.
#[repr(C)]
pub struct AllocatorOfShort {
    _unused: u8,
}
impl AllocatorOfShort {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<short>& std::allocator<short>::operator=(const std::allocator<short>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfShort>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfShort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_short_operator_(
            self as *mut crate::AllocatorOfShort,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfShort>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<short>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfShort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_short_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<short>::allocator(const std::allocator<short>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfShort>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfShort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_short_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfShort>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<unsigned short>```</span>.
#[repr(C)]
pub struct AllocatorOfUshort {
    _unused: u8,
}
impl AllocatorOfUshort {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<unsigned short>& std::allocator<unsigned short>::operator=(const std::allocator<unsigned short>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUshort>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfUshort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_short_operator_(
            self as *mut crate::AllocatorOfUshort,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUshort>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<unsigned short>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfUshort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_short_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<unsigned short>::allocator(const std::allocator<unsigned short>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUshort>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfUshort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_short_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUshort>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<int>```</span>.
#[repr(C)]
pub struct AllocatorOfInt {
    _unused: u8,
}
impl AllocatorOfInt {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<int>& std::allocator<int>::operator=(const std::allocator<int>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfInt>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfInt> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_int_operator_(
            self as *mut crate::AllocatorOfInt,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfInt>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<int>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfInt> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_int_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<int>::allocator(const std::allocator<int>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfInt>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfInt> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_int_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfInt>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<unsigned int>```</span>.
#[repr(C)]
pub struct AllocatorOfUint {
    _unused: u8,
}
impl AllocatorOfUint {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<unsigned int>& std::allocator<unsigned int>::operator=(const std::allocator<unsigned int>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUint>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfUint> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_int_operator_(
            self as *mut crate::AllocatorOfUint,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUint>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<unsigned int>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfUint> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_int_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<unsigned int>::allocator(const std::allocator<unsigned int>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUint>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfUint> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_int_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUint>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<long>```</span>.
#[repr(C)]
pub struct AllocatorOfLong {
    _unused: u8,
}
impl AllocatorOfLong {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<long>& std::allocator<long>::operator=(const std::allocator<long>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfLong>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfLong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_long_operator_(
            self as *mut crate::AllocatorOfLong,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfLong>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<long>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfLong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_long_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<long>::allocator(const std::allocator<long>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfLong>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfLong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_long_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfLong>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<unsigned long>```</span>.
#[repr(C)]
pub struct AllocatorOfUlong {
    _unused: u8,
}
impl AllocatorOfUlong {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<unsigned long>& std::allocator<unsigned long>::operator=(const std::allocator<unsigned long>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUlong>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfUlong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_long_operator_(
            self as *mut crate::AllocatorOfUlong,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUlong>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<unsigned long>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfUlong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_long_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<unsigned long>::allocator(const std::allocator<unsigned long>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUlong>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfUlong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_long_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUlong>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<long long>```</span>.
#[repr(C)]
pub struct AllocatorOfLonglong {
    _unused: u8,
}
impl AllocatorOfLonglong {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<long long>& std::allocator<long long>::operator=(const std::allocator<long long>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfLonglong>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfLonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_long_long_operator_(
            self as *mut crate::AllocatorOfLonglong,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfLonglong>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<long long>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfLonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_long_long_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<long long>::allocator(const std::allocator<long long>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfLonglong>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfLonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_long_long_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfLonglong>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<unsigned long long>```</span>.
#[repr(C)]
pub struct AllocatorOfUlonglong {
    _unused: u8,
}
impl AllocatorOfUlonglong {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<unsigned long long>& std::allocator<unsigned long long>::operator=(const std::allocator<unsigned long long>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUlonglong>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfUlonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_long_long_operator_(
            self as *mut crate::AllocatorOfUlonglong,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUlonglong>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<unsigned long long>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfUlonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_long_long_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<unsigned long long>::allocator(const std::allocator<unsigned long long>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUlonglong>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfUlonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_long_long_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUlonglong>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<float>```</span>.
#[repr(C)]
pub struct AllocatorOfFloat {
    _unused: u8,
}
impl AllocatorOfFloat {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<float>& std::allocator<float>::operator=(const std::allocator<float>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfFloat>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfFloat> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_float_operator_(
            self as *mut crate::AllocatorOfFloat,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfFloat>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<float>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfFloat> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_float_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<float>::allocator(const std::allocator<float>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfFloat>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfFloat> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_float_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfFloat>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<double>```</span>.
#[repr(C)]
pub struct AllocatorOfDouble {
    _unused: u8,
}
impl AllocatorOfDouble {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<double>& std::allocator<double>::operator=(const std::allocator<double>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfDouble>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfDouble> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_double_operator_(
            self as *mut crate::AllocatorOfDouble,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfDouble>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<double>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfDouble> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_double_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<double>::allocator(const std::allocator<double>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfDouble>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfDouble> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_double_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfDouble>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<int8_t>```</span>.
#[repr(C)]
pub struct AllocatorOfI8 {
    _unused: u8,
}
impl AllocatorOfI8 {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<int8_t>& std::allocator<int8_t>::operator=(const std::allocator<int8_t>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI8>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfI8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_int8_t_operator_(
            self as *mut crate::AllocatorOfI8,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI8>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<int8_t>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfI8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_int8_t_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<int8_t>::allocator(const std::allocator<int8_t>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI8>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfI8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_int8_t_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI8>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<uint8_t>```</span>.
#[repr(C)]
pub struct AllocatorOfU8 {
    _unused: u8,
}
impl AllocatorOfU8 {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<uint8_t>& std::allocator<uint8_t>::operator=(const std::allocator<uint8_t>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU8>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfU8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint8_t_operator_(
            self as *mut crate::AllocatorOfU8,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU8>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<uint8_t>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfU8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint8_t_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<uint8_t>::allocator(const std::allocator<uint8_t>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU8>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfU8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint8_t_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU8>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<int16_t>```</span>.
#[repr(C)]
pub struct AllocatorOfI16 {
    _unused: u8,
}
impl AllocatorOfI16 {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<int16_t>& std::allocator<int16_t>::operator=(const std::allocator<int16_t>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI16>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfI16> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_int16_t_operator_(
            self as *mut crate::AllocatorOfI16,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI16>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<int16_t>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfI16> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_int16_t_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<int16_t>::allocator(const std::allocator<int16_t>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI16>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfI16> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_int16_t_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI16>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<uint16_t>```</span>.
#[repr(C)]
pub struct AllocatorOfU16 {
    _unused: u8,
}
impl AllocatorOfU16 {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<uint16_t>& std::allocator<uint16_t>::operator=(const std::allocator<uint16_t>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU16>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfU16> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint16_t_operator_(
            self as *mut crate::AllocatorOfU16,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU16>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<uint16_t>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfU16> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint16_t_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<uint16_t>::allocator(const std::allocator<uint16_t>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU16>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfU16> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint16_t_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU16>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<int32_t>```</span>.
#[repr(C)]
pub struct AllocatorOfI32 {
    _unused: u8,
}
impl AllocatorOfI32 {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<int32_t>& std::allocator<int32_t>::operator=(const std::allocator<int32_t>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI32>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfI32> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_int32_t_operator_(
            self as *mut crate::AllocatorOfI32,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI32>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<int32_t>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfI32> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_int32_t_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<int32_t>::allocator(const std::allocator<int32_t>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI32>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfI32> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_int32_t_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI32>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<uint32_t>```</span>.
#[repr(C)]
pub struct AllocatorOfU32 {
    _unused: u8,
}
impl AllocatorOfU32 {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<uint32_t>& std::allocator<uint32_t>::operator=(const std::allocator<uint32_t>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU32>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfU32> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint32_t_operator_(
            self as *mut crate::AllocatorOfU32,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU32>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<uint32_t>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfU32> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint32_t_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<uint32_t>::allocator(const std::allocator<uint32_t>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU32>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfU32> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint32_t_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU32>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<int64_t>```</span>.
#[repr(C)]
pub struct AllocatorOfI64 {
    _unused: u8,
}
impl AllocatorOfI64 {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<int64_t>& std::allocator<int64_t>::operator=(const std::allocator<int64_t>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI64>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfI64> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_int64_t_operator_(
            self as *mut crate::AllocatorOfI64,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI64>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<int64_t>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfI64> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_int64_t_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<int64_t>::allocator(const std::allocator<int64_t>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI64>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfI64> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_int64_t_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI64>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<uint64_t>```</span>.
#[repr(C)]
pub struct AllocatorOfU64 {
    _unused: u8,
}
impl AllocatorOfU64 {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<uint64_t>& std::allocator<uint64_t>::operator=(const std::allocator<uint64_t>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU64>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfU64> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint64_t_operator_(
            self as *mut crate::AllocatorOfU64,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU64>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<uint64_t>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfU64> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint64_t_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<uint64_t>::allocator(const std::allocator<uint64_t>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU64>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfU64> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint64_t_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU64>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<size_t>```</span>.
#[repr(C)]
pub struct AllocatorOfUsize {
    _unused: u8,
}
impl AllocatorOfUsize {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<size_t>& std::allocator<size_t>::operator=(const std::allocator<size_t>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUsize>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfUsize> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_size_t_operator_(
            self as *mut crate::AllocatorOfUsize,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUsize>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<size_t>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfUsize> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_size_t_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<size_t>::allocator(const std::allocator<size_t>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUsize>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfUsize> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_size_t_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUsize>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::allocator<void*>```</span>.
#[repr(C)]
pub struct AllocatorOfVoid {
    _unused: u8,
}
impl AllocatorOfVoid {
    /// Calls C++ function: <span style='color: green;'>```std::allocator<void*>& std::allocator<void*>::operator=(const std::allocator<void*>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfVoid>>,
    ) -> ::cpp_core::MutRef<crate::AllocatorOfVoid> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_void_ptr_operator_(
            self as *mut crate::AllocatorOfVoid,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfVoid>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<void*>::allocator()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::AllocatorOfVoid> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_void_ptr_allocator();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::allocator<void*>::allocator(const std::allocator<void*>& __a)```</span>.
    pub unsafe fn new_copy(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfVoid>>,
    ) -> ::cpp_core::CppBox<crate::AllocatorOfVoid> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_allocator_void_ptr_allocator1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfVoid>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```std::vector<bool, std::allocator<bool>>```</span>.
#[repr(C)]
pub struct VectorOfBool {
    _unused: u8,
}
impl VectorOfBool {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<bool, std::allocator<bool>>::assign(size_t __n, const bool& __val)```</span>.
    pub unsafe fn assign_usize_bool(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<bool>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_assign(
            self as *mut crate::VectorOfBool,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<bool>>::cast_into(val).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<bool, std::allocator<bool>>::assign(const bool* first, const bool* last)```</span>.
    pub unsafe fn assign_2_bool(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<bool>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<bool>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_assign1(
            self as *mut crate::VectorOfBool,
            ::cpp_core::CastInto::<::cpp_core::Ptr<bool>>::cast_into(first).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<bool>>::cast_into(last).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<bool, std::allocator<bool>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_capacity(
            self as *const crate::VectorOfBool,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<bool, std::allocator<bool>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_clear(
            self as *mut crate::VectorOfBool,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<bool, std::allocator<bool>>& std::vector<bool, std::allocator<bool>>::operator=(const std::vector<bool, std::allocator<bool>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfBool>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfBool> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_operator_(
            self as *mut crate::VectorOfBool,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfBool>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<bool, std::allocator<bool>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_empty(
            self as *const crate::VectorOfBool,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<bool, std::allocator<bool>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_max_size(
            self as *const crate::VectorOfBool,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<bool, std::allocator<bool>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfBool> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<bool, std::allocator<bool>>::vector(const std::allocator<bool>& __a)```</span>.
    pub unsafe fn from_allocator_of_bool(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfBool>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfBool> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_vector2(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfBool>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<bool, std::allocator<bool>>::vector(size_t __n, const std::allocator<bool>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_bool(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfBool>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfBool> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_vector3(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfBool>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<bool, std::allocator<bool>>::vector(size_t __n, const bool& __value, const std::allocator<bool>& __a = …)```</span>.
    pub unsafe fn from_usize_bool_allocator_of_bool(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<bool>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfBool>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfBool> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_vector4(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<bool>>::cast_into(value).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfBool>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<bool, std::allocator<bool>>::vector(const std::vector<bool, std::allocator<bool>>& __x, const std::allocator<bool>& __a)```</span>.
    pub unsafe fn from_vector_of_bool_allocator_of_bool(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfBool>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfBool>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfBool> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_vector6(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfBool>>::cast_into(x).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfBool>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<bool, std::allocator<bool>>::vector(const bool* first, const bool* last, std::allocator<bool> alloc = …)```</span>.
    pub unsafe fn from_2_bool_allocator_of_bool(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<bool>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<bool>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfBool>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfBool> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_vector8(
            ::cpp_core::CastInto::<::cpp_core::Ptr<bool>>::cast_into(first).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<bool>>::cast_into(last).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfBool>>::cast_into(alloc)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<bool, std::allocator<bool>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfBool> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<bool, std::allocator<bool>>::vector(size_t __n, const bool& __value)```</span>.
    pub unsafe fn from_usize_bool(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<bool>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfBool> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_vector10(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<bool>>::cast_into(value).as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<bool, std::allocator<bool>>::vector(const bool* first, const bool* last)```</span>.
    pub unsafe fn from_2_bool(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<bool>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<bool>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfBool> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_vector11(
            ::cpp_core::CastInto::<::cpp_core::Ptr<bool>>::cast_into(first).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<bool>>::cast_into(last).as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<bool, std::allocator<bool>>::vector(const std::vector<bool, std::allocator<bool>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfBool>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfBool> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_vector1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfBool>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<bool, std::allocator<bool>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_pop_back(
            self as *mut crate::VectorOfBool,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<bool, std::allocator<bool>>::push_back(const bool& __x)```</span>.
    pub unsafe fn push_back(&mut self, x: impl ::cpp_core::CastInto<::cpp_core::Ref<bool>>) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_push_back(
            self as *mut crate::VectorOfBool,
            ::cpp_core::CastInto::<::cpp_core::Ref<bool>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<bool, std::allocator<bool>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_reserve(
            self as *mut crate::VectorOfBool,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<bool, std::allocator<bool>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_resize(
            self as *mut crate::VectorOfBool,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<bool, std::allocator<bool>>::resize(size_t __new_size, const bool& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<bool>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_resize1(
            self as *mut crate::VectorOfBool,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<bool>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<bool, std::allocator<bool>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_shrink_to_fit(
            self as *mut crate::VectorOfBool,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<bool, std::allocator<bool>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_size(
            self as *const crate::VectorOfBool,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<bool, std::allocator<bool>>::swap(std::vector<bool, std::allocator<bool>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfBool>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_swap(
            self as *mut crate::VectorOfBool,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfBool>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<char, std::allocator<char>>```</span>.
#[repr(C)]
pub struct VectorOfChar {
    _unused: u8,
}
impl VectorOfChar {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<char, std::allocator<char>>::assign(size_t __n, const char& __val)```</span>.
    pub unsafe fn assign_usize_char(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_char>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_assign(
            self as *mut crate::VectorOfChar,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_char>>::cast_into(val)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char, std::allocator<char>>::assign(const char* first, const char* last)```</span>.
    pub unsafe fn assign_2_char(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_assign1(
            self as *mut crate::VectorOfChar,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(last)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```char& std::vector<char, std::allocator<char>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_at(
            self as *mut crate::VectorOfChar,
            n,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char& std::vector<char, std::allocator<char>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_at1(
            self as *const crate::VectorOfChar,
            n,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char& std::vector<char, std::allocator<char>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_back(
            self as *mut crate::VectorOfChar,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char& std::vector<char, std::allocator<char>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_back1(
            self as *const crate::VectorOfChar,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<char, std::allocator<char>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_capacity(
            self as *const crate::VectorOfChar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char, std::allocator<char>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_clear(
            self as *mut crate::VectorOfChar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<char, std::allocator<char>>& std::vector<char, std::allocator<char>>::operator=(const std::vector<char, std::allocator<char>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfChar>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_operator_(
            self as *mut crate::VectorOfChar,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfChar>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char* std::vector<char, std::allocator<char>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_data(
            self as *mut crate::VectorOfChar,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const char* std::vector<char, std::allocator<char>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_data1(
            self as *const crate::VectorOfChar,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<char, std::allocator<char>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_empty(
            self as *const crate::VectorOfChar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```char& std::vector<char, std::allocator<char>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_front(
            self as *mut crate::VectorOfChar,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char& std::vector<char, std::allocator<char>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_front1(
            self as *const crate::VectorOfChar,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char& std::vector<char, std::allocator<char>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_char> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_operator__(
                self as *mut crate::VectorOfChar,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char& std::vector<char, std::allocator<char>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_char> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_operator__1(
                self as *const crate::VectorOfChar,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<char, std::allocator<char>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_max_size(
            self as *const crate::VectorOfChar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char, std::allocator<char>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char, std::allocator<char>>::vector(const std::allocator<char>& __a)```</span>.
    pub unsafe fn from_allocator_of_char(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_vector2(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char, std::allocator<char>>::vector(size_t __n, const std::allocator<char>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_char(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_vector3(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char, std::allocator<char>>::vector(size_t __n, const char& __value, const std::allocator<char>& __a = …)```</span>.
    pub unsafe fn from_usize_char_allocator_of_char(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_char>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_vector4(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_char>>::cast_into(value)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char, std::allocator<char>>::vector(const std::vector<char, std::allocator<char>>& __x, const std::allocator<char>& __a)```</span>.
    pub unsafe fn from_vector_of_char_allocator_of_char(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfChar>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_vector6(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfChar>>::cast_into(x).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char, std::allocator<char>>::vector(const char* first, const char* last, std::allocator<char> alloc = …)```</span>.
    pub unsafe fn from_2_char_allocator_of_char(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_vector8(
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(last)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar>>::cast_into(alloc)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char, std::allocator<char>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfChar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char, std::allocator<char>>::vector(size_t __n, const char& __value)```</span>.
    pub unsafe fn from_usize_char(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_char>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_vector10(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_char>>::cast_into(value)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char, std::allocator<char>>::vector(const char* first, const char* last)```</span>.
    pub unsafe fn from_2_char(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_vector11(
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(last)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char, std::allocator<char>>::vector(const std::vector<char, std::allocator<char>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfChar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_vector1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfChar>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char, std::allocator<char>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_pop_back(
            self as *mut crate::VectorOfChar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char, std::allocator<char>>::push_back(const char& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_char>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_push_back(
            self as *mut crate::VectorOfChar,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_char>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char, std::allocator<char>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_reserve(
            self as *mut crate::VectorOfChar,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char, std::allocator<char>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_resize(
            self as *mut crate::VectorOfChar,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char, std::allocator<char>>::resize(size_t __new_size, const char& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_char>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_resize1(
            self as *mut crate::VectorOfChar,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_char>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char, std::allocator<char>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_shrink_to_fit(
            self as *mut crate::VectorOfChar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<char, std::allocator<char>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_size(
            self as *const crate::VectorOfChar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char, std::allocator<char>>::swap(std::vector<char, std::allocator<char>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfChar>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_swap(
            self as *mut crate::VectorOfChar,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfChar>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<signed char, std::allocator<signed char>>```</span>.
#[repr(C)]
pub struct VectorOfSchar {
    _unused: u8,
}
impl VectorOfSchar {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<signed char, std::allocator<signed char>>::assign(size_t __n, const signed char& __val)```</span>.
    pub unsafe fn assign_usize_schar(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_schar>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_assign(
            self as *mut crate::VectorOfSchar,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_schar>>::cast_into(val)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<signed char, std::allocator<signed char>>::assign(const signed char* first, const signed char* last)```</span>.
    pub unsafe fn assign_2_schar(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_schar>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_schar>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_assign1(
            self as *mut crate::VectorOfSchar,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_schar>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_schar>>::cast_into(last)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```signed char& std::vector<signed char, std::allocator<signed char>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_schar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_at(
                self as *mut crate::VectorOfSchar,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const signed char& std::vector<signed char, std::allocator<signed char>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_schar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_at1(
                self as *const crate::VectorOfSchar,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```signed char& std::vector<signed char, std::allocator<signed char>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_schar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_back(
                self as *mut crate::VectorOfSchar,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const signed char& std::vector<signed char, std::allocator<signed char>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::std::os::raw::c_schar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_back1(
                self as *const crate::VectorOfSchar,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<signed char, std::allocator<signed char>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_capacity(
            self as *const crate::VectorOfSchar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<signed char, std::allocator<signed char>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_clear(
            self as *mut crate::VectorOfSchar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<signed char, std::allocator<signed char>>& std::vector<signed char, std::allocator<signed char>>::operator=(const std::vector<signed char, std::allocator<signed char>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfSchar>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfSchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_operator_(self as *mut crate::VectorOfSchar, ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfSchar>>::cast_into(other).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```signed char* std::vector<signed char, std::allocator<signed char>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_schar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_data(
                self as *mut crate::VectorOfSchar,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const signed char* std::vector<signed char, std::allocator<signed char>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_schar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_data1(
                self as *const crate::VectorOfSchar,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<signed char, std::allocator<signed char>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_empty(
            self as *const crate::VectorOfSchar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```signed char& std::vector<signed char, std::allocator<signed char>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_schar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_front(
                self as *mut crate::VectorOfSchar,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const signed char& std::vector<signed char, std::allocator<signed char>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::std::os::raw::c_schar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_front1(
                self as *const crate::VectorOfSchar,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```signed char& std::vector<signed char, std::allocator<signed char>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_schar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_operator__(self as *mut crate::VectorOfSchar, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const signed char& std::vector<signed char, std::allocator<signed char>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_schar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_operator__1(self as *const crate::VectorOfSchar, n);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<signed char, std::allocator<signed char>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_max_size(
            self as *const crate::VectorOfSchar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<signed char, std::allocator<signed char>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfSchar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<signed char, std::allocator<signed char>>::vector(const std::allocator<signed char>& __a)```</span>.
    pub unsafe fn from_allocator_of_schar(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfSchar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfSchar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfSchar>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<signed char, std::allocator<signed char>>::vector(size_t __n, const std::allocator<signed char>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_schar(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfSchar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfSchar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfSchar>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<signed char, std::allocator<signed char>>::vector(size_t __n, const signed char& __value, const std::allocator<signed char>& __a = …)```</span>.
    pub unsafe fn from_usize_schar_allocator_of_schar(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_schar>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfSchar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfSchar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_vector4(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_schar>>::cast_into(value)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfSchar>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<signed char, std::allocator<signed char>>::vector(const std::vector<signed char, std::allocator<signed char>>& __x, const std::allocator<signed char>& __a)```</span>.
    pub unsafe fn from_vector_of_schar_allocator_of_schar(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfSchar>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfSchar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfSchar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfSchar>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfSchar>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<signed char, std::allocator<signed char>>::vector(const signed char* first, const signed char* last, std::allocator<signed char> alloc = …)```</span>.
    pub unsafe fn from_2_schar_allocator_of_schar(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_schar>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_schar>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfSchar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfSchar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_vector8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_schar>>::cast_into(first)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_schar>>::cast_into(last)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfSchar>>::cast_into(alloc)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<signed char, std::allocator<signed char>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfSchar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_vector9(
                n,
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<signed char, std::allocator<signed char>>::vector(size_t __n, const signed char& __value)```</span>.
    pub unsafe fn from_usize_schar(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_schar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfSchar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_schar>>::cast_into(value)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<signed char, std::allocator<signed char>>::vector(const signed char* first, const signed char* last)```</span>.
    pub unsafe fn from_2_schar(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_schar>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_schar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfSchar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_schar>>::cast_into(first)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_schar>>::cast_into(last)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<signed char, std::allocator<signed char>>::vector(const std::vector<signed char, std::allocator<signed char>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfSchar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfSchar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfSchar>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<signed char, std::allocator<signed char>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_pop_back(
            self as *mut crate::VectorOfSchar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<signed char, std::allocator<signed char>>::push_back(const signed char& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_schar>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_push_back(
            self as *mut crate::VectorOfSchar,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_schar>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<signed char, std::allocator<signed char>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_reserve(
            self as *mut crate::VectorOfSchar,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<signed char, std::allocator<signed char>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_resize(
            self as *mut crate::VectorOfSchar,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<signed char, std::allocator<signed char>>::resize(size_t __new_size, const signed char& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_schar>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_resize1(
            self as *mut crate::VectorOfSchar,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_schar>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<signed char, std::allocator<signed char>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_shrink_to_fit(
            self as *mut crate::VectorOfSchar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<signed char, std::allocator<signed char>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_size(
            self as *const crate::VectorOfSchar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<signed char, std::allocator<signed char>>::swap(std::vector<signed char, std::allocator<signed char>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfSchar>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_swap(
            self as *mut crate::VectorOfSchar,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfSchar>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<unsigned char, std::allocator<unsigned char>>```</span>.
#[repr(C)]
pub struct VectorOfUchar {
    _unused: u8,
}
impl VectorOfUchar {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned char, std::allocator<unsigned char>>::assign(size_t __n, const unsigned char& __val)```</span>.
    pub unsafe fn assign_usize_uchar(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_uchar>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_assign(
            self as *mut crate::VectorOfUchar,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_uchar>>::cast_into(val)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned char, std::allocator<unsigned char>>::assign(const unsigned char* first, const unsigned char* last)```</span>.
    pub unsafe fn assign_2_uchar(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_uchar>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_uchar>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_assign1(
            self as *mut crate::VectorOfUchar,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_uchar>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_uchar>>::cast_into(last)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned char& std::vector<unsigned char, std::allocator<unsigned char>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_uchar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_at(
                self as *mut crate::VectorOfUchar,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned char& std::vector<unsigned char, std::allocator<unsigned char>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_uchar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_at1(
                self as *const crate::VectorOfUchar,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned char& std::vector<unsigned char, std::allocator<unsigned char>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_uchar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_back(
                self as *mut crate::VectorOfUchar,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned char& std::vector<unsigned char, std::allocator<unsigned char>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::std::os::raw::c_uchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_back1(self as *const crate::VectorOfUchar);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned char, std::allocator<unsigned char>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_capacity(
            self as *const crate::VectorOfUchar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned char, std::allocator<unsigned char>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_clear(
            self as *mut crate::VectorOfUchar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<unsigned char, std::allocator<unsigned char>>& std::vector<unsigned char, std::allocator<unsigned char>>::operator=(const std::vector<unsigned char, std::allocator<unsigned char>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUchar>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfUchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_operator_(self as *mut crate::VectorOfUchar, ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUchar>>::cast_into(other).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned char* std::vector<unsigned char, std::allocator<unsigned char>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_uchar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_data(
                self as *mut crate::VectorOfUchar,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned char* std::vector<unsigned char, std::allocator<unsigned char>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_uchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_data1(self as *const crate::VectorOfUchar);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<unsigned char, std::allocator<unsigned char>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_empty(
            self as *const crate::VectorOfUchar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned char& std::vector<unsigned char, std::allocator<unsigned char>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_uchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_front(self as *mut crate::VectorOfUchar);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned char& std::vector<unsigned char, std::allocator<unsigned char>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::std::os::raw::c_uchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_front1(self as *const crate::VectorOfUchar);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned char& std::vector<unsigned char, std::allocator<unsigned char>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_uchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_operator__(self as *mut crate::VectorOfUchar, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned char& std::vector<unsigned char, std::allocator<unsigned char>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_uchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_operator__1(self as *const crate::VectorOfUchar, n);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned char, std::allocator<unsigned char>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_max_size(
            self as *const crate::VectorOfUchar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned char, std::allocator<unsigned char>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfUchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned char, std::allocator<unsigned char>>::vector(const std::allocator<unsigned char>& __a)```</span>.
    pub unsafe fn from_allocator_of_uchar(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUchar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_vector2(::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUchar>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned char, std::allocator<unsigned char>>::vector(size_t __n, const std::allocator<unsigned char>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_uchar(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUchar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_vector3(n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUchar>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned char, std::allocator<unsigned char>>::vector(size_t __n, const unsigned char& __value, const std::allocator<unsigned char>& __a = …)```</span>.
    pub unsafe fn from_usize_uchar_allocator_of_uchar(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_uchar>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUchar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_vector4(n, ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_uchar>>::cast_into(value).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUchar>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned char, std::allocator<unsigned char>>::vector(const std::vector<unsigned char, std::allocator<unsigned char>>& __x, const std::allocator<unsigned char>& __a)```</span>.
    pub unsafe fn from_vector_of_uchar_allocator_of_uchar(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUchar>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUchar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_vector6(::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUchar>>::cast_into(x).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUchar>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned char, std::allocator<unsigned char>>::vector(const unsigned char* first, const unsigned char* last, std::allocator<unsigned char> alloc = …)```</span>.
    pub unsafe fn from_2_uchar_allocator_of_uchar(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_uchar>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_uchar>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUchar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_vector8(::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_uchar>>::cast_into(first).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_uchar>>::cast_into(last).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUchar>>::cast_into(alloc).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned char, std::allocator<unsigned char>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfUchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned char, std::allocator<unsigned char>>::vector(size_t __n, const unsigned char& __value)```</span>.
    pub unsafe fn from_usize_uchar(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_uchar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_vector10(n, ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_uchar>>::cast_into(value).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned char, std::allocator<unsigned char>>::vector(const unsigned char* first, const unsigned char* last)```</span>.
    pub unsafe fn from_2_uchar(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_uchar>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_uchar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_vector11(::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_uchar>>::cast_into(first).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_uchar>>::cast_into(last).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned char, std::allocator<unsigned char>>::vector(const std::vector<unsigned char, std::allocator<unsigned char>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUchar>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_vector1(::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUchar>>::cast_into(other).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned char, std::allocator<unsigned char>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_pop_back(
            self as *mut crate::VectorOfUchar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned char, std::allocator<unsigned char>>::push_back(const unsigned char& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_uchar>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_push_back(
            self as *mut crate::VectorOfUchar,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_uchar>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned char, std::allocator<unsigned char>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_reserve(
            self as *mut crate::VectorOfUchar,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned char, std::allocator<unsigned char>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_resize(
            self as *mut crate::VectorOfUchar,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned char, std::allocator<unsigned char>>::resize(size_t __new_size, const unsigned char& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_uchar>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_resize1(
            self as *mut crate::VectorOfUchar,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_uchar>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned char, std::allocator<unsigned char>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_shrink_to_fit(self as *mut crate::VectorOfUchar)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned char, std::allocator<unsigned char>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_size(
            self as *const crate::VectorOfUchar,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned char, std::allocator<unsigned char>>::swap(std::vector<unsigned char, std::allocator<unsigned char>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUchar>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_swap(
            self as *mut crate::VectorOfUchar,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUchar>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<wchar_t, std::allocator<wchar_t>>```</span>.
#[repr(C)]
pub struct VectorOfWcharT {
    _unused: u8,
}
impl VectorOfWcharT {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<wchar_t, std::allocator<wchar_t>>::assign(size_t __n, const wchar_t& __val)```</span>.
    pub unsafe fn assign_usize_wchar_t(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::cpp_core::wchar_t>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_assign(
            self as *mut crate::VectorOfWcharT,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::cpp_core::wchar_t>>::cast_into(val)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<wchar_t, std::allocator<wchar_t>>::assign(const wchar_t* first, const wchar_t* last)```</span>.
    pub unsafe fn assign_2_wchar_t(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_assign1(
            self as *mut crate::VectorOfWcharT,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(last)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```wchar_t& std::vector<wchar_t, std::allocator<wchar_t>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::cpp_core::wchar_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_at(
            self as *mut crate::VectorOfWcharT,
            n,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const wchar_t& std::vector<wchar_t, std::allocator<wchar_t>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::cpp_core::wchar_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_at1(
            self as *const crate::VectorOfWcharT,
            n,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```wchar_t& std::vector<wchar_t, std::allocator<wchar_t>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::cpp_core::wchar_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_back(
                self as *mut crate::VectorOfWcharT,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const wchar_t& std::vector<wchar_t, std::allocator<wchar_t>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::cpp_core::wchar_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_back1(
                self as *const crate::VectorOfWcharT,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<wchar_t, std::allocator<wchar_t>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_capacity(
            self as *const crate::VectorOfWcharT,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<wchar_t, std::allocator<wchar_t>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_clear(
            self as *mut crate::VectorOfWcharT,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<wchar_t, std::allocator<wchar_t>>& std::vector<wchar_t, std::allocator<wchar_t>>::operator=(const std::vector<wchar_t, std::allocator<wchar_t>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfWcharT>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfWcharT> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_operator_(
                self as *mut crate::VectorOfWcharT,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfWcharT>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```wchar_t* std::vector<wchar_t, std::allocator<wchar_t>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::cpp_core::wchar_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_data(
                self as *mut crate::VectorOfWcharT,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const wchar_t* std::vector<wchar_t, std::allocator<wchar_t>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::cpp_core::wchar_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_data1(
                self as *const crate::VectorOfWcharT,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<wchar_t, std::allocator<wchar_t>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_empty(
            self as *const crate::VectorOfWcharT,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```wchar_t& std::vector<wchar_t, std::allocator<wchar_t>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::cpp_core::wchar_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_front(
                self as *mut crate::VectorOfWcharT,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const wchar_t& std::vector<wchar_t, std::allocator<wchar_t>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::cpp_core::wchar_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_front1(
                self as *const crate::VectorOfWcharT,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```wchar_t& std::vector<wchar_t, std::allocator<wchar_t>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::cpp_core::wchar_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_operator__(
                self as *mut crate::VectorOfWcharT,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const wchar_t& std::vector<wchar_t, std::allocator<wchar_t>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::cpp_core::wchar_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_operator__1(
                self as *const crate::VectorOfWcharT,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<wchar_t, std::allocator<wchar_t>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_max_size(
            self as *const crate::VectorOfWcharT,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<wchar_t, std::allocator<wchar_t>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfWcharT> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<wchar_t, std::allocator<wchar_t>>::vector(const std::allocator<wchar_t>& __a)```</span>.
    pub unsafe fn from_allocator_of_wchar_t(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfWcharT>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfWcharT> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfWcharT>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<wchar_t, std::allocator<wchar_t>>::vector(size_t __n, const std::allocator<wchar_t>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_wchar_t(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfWcharT>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfWcharT> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfWcharT>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<wchar_t, std::allocator<wchar_t>>::vector(size_t __n, const wchar_t& __value, const std::allocator<wchar_t>& __a = …)```</span>.
    pub unsafe fn from_usize_wchar_t_allocator_of_wchar_t(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::cpp_core::wchar_t>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfWcharT>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfWcharT> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_vector4(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<::cpp_core::wchar_t>>::cast_into(value)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfWcharT>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<wchar_t, std::allocator<wchar_t>>::vector(const std::vector<wchar_t, std::allocator<wchar_t>>& __x, const std::allocator<wchar_t>& __a)```</span>.
    pub unsafe fn from_vector_of_wchar_t_allocator_of_wchar_t(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfWcharT>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfWcharT>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfWcharT> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfWcharT>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfWcharT>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<wchar_t, std::allocator<wchar_t>>::vector(const wchar_t* first, const wchar_t* last, std::allocator<wchar_t> alloc = …)```</span>.
    pub unsafe fn from_2_wchar_t_allocator_of_wchar_t(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfWcharT>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfWcharT> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_vector8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(first)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(last)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfWcharT>>::cast_into(alloc)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<wchar_t, std::allocator<wchar_t>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfWcharT> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<wchar_t, std::allocator<wchar_t>>::vector(size_t __n, const wchar_t& __value)```</span>.
    pub unsafe fn from_usize_wchar_t(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::cpp_core::wchar_t>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfWcharT> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<::cpp_core::wchar_t>>::cast_into(value)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<wchar_t, std::allocator<wchar_t>>::vector(const wchar_t* first, const wchar_t* last)```</span>.
    pub unsafe fn from_2_wchar_t(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfWcharT> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(first)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(last)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<wchar_t, std::allocator<wchar_t>>::vector(const std::vector<wchar_t, std::allocator<wchar_t>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfWcharT>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfWcharT> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfWcharT>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<wchar_t, std::allocator<wchar_t>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_pop_back(
            self as *mut crate::VectorOfWcharT,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<wchar_t, std::allocator<wchar_t>>::push_back(const wchar_t& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::cpp_core::wchar_t>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_push_back(
            self as *mut crate::VectorOfWcharT,
            ::cpp_core::CastInto::<::cpp_core::Ref<::cpp_core::wchar_t>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<wchar_t, std::allocator<wchar_t>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_reserve(
            self as *mut crate::VectorOfWcharT,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<wchar_t, std::allocator<wchar_t>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_resize(
            self as *mut crate::VectorOfWcharT,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<wchar_t, std::allocator<wchar_t>>::resize(size_t __new_size, const wchar_t& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::cpp_core::wchar_t>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_resize1(
            self as *mut crate::VectorOfWcharT,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<::cpp_core::wchar_t>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<wchar_t, std::allocator<wchar_t>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_shrink_to_fit(
            self as *mut crate::VectorOfWcharT,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<wchar_t, std::allocator<wchar_t>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_size(
            self as *const crate::VectorOfWcharT,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<wchar_t, std::allocator<wchar_t>>::swap(std::vector<wchar_t, std::allocator<wchar_t>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfWcharT>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_swap(
            self as *mut crate::VectorOfWcharT,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfWcharT>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<char16_t, std::allocator<char16_t>>```</span>.
#[repr(C)]
pub struct VectorOfChar16T {
    _unused: u8,
}
impl VectorOfChar16T {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<char16_t, std::allocator<char16_t>>::assign(size_t __n, const char16_t& __val)```</span>.
    pub unsafe fn assign_usize_char16_t(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::cpp_core::char16_t>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_assign(
            self as *mut crate::VectorOfChar16T,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::cpp_core::char16_t>>::cast_into(val)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char16_t, std::allocator<char16_t>>::assign(const char16_t* first, const char16_t* last)```</span>.
    pub unsafe fn assign_2_char16_t(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_assign1(
            self as *mut crate::VectorOfChar16T,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(last)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```char16_t& std::vector<char16_t, std::allocator<char16_t>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::cpp_core::char16_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_at(
                self as *mut crate::VectorOfChar16T,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char16_t& std::vector<char16_t, std::allocator<char16_t>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::cpp_core::char16_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_at1(
                self as *const crate::VectorOfChar16T,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char16_t& std::vector<char16_t, std::allocator<char16_t>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::cpp_core::char16_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_back(
                self as *mut crate::VectorOfChar16T,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char16_t& std::vector<char16_t, std::allocator<char16_t>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::cpp_core::char16_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_back1(
                self as *const crate::VectorOfChar16T,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<char16_t, std::allocator<char16_t>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_capacity(
            self as *const crate::VectorOfChar16T,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char16_t, std::allocator<char16_t>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_clear(
            self as *mut crate::VectorOfChar16T,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<char16_t, std::allocator<char16_t>>& std::vector<char16_t, std::allocator<char16_t>>::operator=(const std::vector<char16_t, std::allocator<char16_t>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfChar16T>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfChar16T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_operator_(
                self as *mut crate::VectorOfChar16T,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfChar16T>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char16_t* std::vector<char16_t, std::allocator<char16_t>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::cpp_core::char16_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_data(
                self as *mut crate::VectorOfChar16T,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const char16_t* std::vector<char16_t, std::allocator<char16_t>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::cpp_core::char16_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_data1(
                self as *const crate::VectorOfChar16T,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<char16_t, std::allocator<char16_t>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_empty(
            self as *const crate::VectorOfChar16T,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```char16_t& std::vector<char16_t, std::allocator<char16_t>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::cpp_core::char16_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_front(
                self as *mut crate::VectorOfChar16T,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char16_t& std::vector<char16_t, std::allocator<char16_t>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::cpp_core::char16_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_front1(
                self as *const crate::VectorOfChar16T,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char16_t& std::vector<char16_t, std::allocator<char16_t>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::cpp_core::char16_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_operator__(
                self as *mut crate::VectorOfChar16T,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char16_t& std::vector<char16_t, std::allocator<char16_t>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::cpp_core::char16_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_operator__1(
                self as *const crate::VectorOfChar16T,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<char16_t, std::allocator<char16_t>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_max_size(
            self as *const crate::VectorOfChar16T,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char16_t, std::allocator<char16_t>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfChar16T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char16_t, std::allocator<char16_t>>::vector(const std::allocator<char16_t>& __a)```</span>.
    pub unsafe fn from_allocator_of_char16_t(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar16T>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar16T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar16T>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char16_t, std::allocator<char16_t>>::vector(size_t __n, const std::allocator<char16_t>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_char16_t(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar16T>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar16T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar16T>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char16_t, std::allocator<char16_t>>::vector(size_t __n, const char16_t& __value, const std::allocator<char16_t>& __a = …)```</span>.
    pub unsafe fn from_usize_char16_t_allocator_of_char16_t(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::cpp_core::char16_t>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar16T>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar16T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_vector4(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<::cpp_core::char16_t>>::cast_into(value)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar16T>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char16_t, std::allocator<char16_t>>::vector(const std::vector<char16_t, std::allocator<char16_t>>& __x, const std::allocator<char16_t>& __a)```</span>.
    pub unsafe fn from_vector_of_char16_t_allocator_of_char16_t(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfChar16T>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar16T>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar16T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfChar16T>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar16T>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char16_t, std::allocator<char16_t>>::vector(const char16_t* first, const char16_t* last, std::allocator<char16_t> alloc = …)```</span>.
    pub unsafe fn from_2_char16_t_allocator_of_char16_t(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar16T>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar16T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_vector8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(first)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(last)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar16T>>::cast_into(
                    alloc,
                )
                .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char16_t, std::allocator<char16_t>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfChar16T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char16_t, std::allocator<char16_t>>::vector(size_t __n, const char16_t& __value)```</span>.
    pub unsafe fn from_usize_char16_t(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::cpp_core::char16_t>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar16T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<::cpp_core::char16_t>>::cast_into(value)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char16_t, std::allocator<char16_t>>::vector(const char16_t* first, const char16_t* last)```</span>.
    pub unsafe fn from_2_char16_t(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar16T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(first)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(last)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char16_t, std::allocator<char16_t>>::vector(const std::vector<char16_t, std::allocator<char16_t>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfChar16T>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar16T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfChar16T>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char16_t, std::allocator<char16_t>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_pop_back(
            self as *mut crate::VectorOfChar16T,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char16_t, std::allocator<char16_t>>::push_back(const char16_t& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::cpp_core::char16_t>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_push_back(
            self as *mut crate::VectorOfChar16T,
            ::cpp_core::CastInto::<::cpp_core::Ref<::cpp_core::char16_t>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char16_t, std::allocator<char16_t>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_reserve(
            self as *mut crate::VectorOfChar16T,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char16_t, std::allocator<char16_t>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_resize(
            self as *mut crate::VectorOfChar16T,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char16_t, std::allocator<char16_t>>::resize(size_t __new_size, const char16_t& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::cpp_core::char16_t>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_resize1(
            self as *mut crate::VectorOfChar16T,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<::cpp_core::char16_t>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char16_t, std::allocator<char16_t>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_shrink_to_fit(
            self as *mut crate::VectorOfChar16T,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<char16_t, std::allocator<char16_t>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_size(
            self as *const crate::VectorOfChar16T,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char16_t, std::allocator<char16_t>>::swap(std::vector<char16_t, std::allocator<char16_t>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfChar16T>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_swap(
            self as *mut crate::VectorOfChar16T,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfChar16T>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<char32_t, std::allocator<char32_t>>```</span>.
#[repr(C)]
pub struct VectorOfChar32T {
    _unused: u8,
}
impl VectorOfChar32T {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<char32_t, std::allocator<char32_t>>::assign(size_t __n, const char32_t& __val)```</span>.
    pub unsafe fn assign_usize_char32_t(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::cpp_core::char32_t>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_assign(
            self as *mut crate::VectorOfChar32T,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::cpp_core::char32_t>>::cast_into(val)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char32_t, std::allocator<char32_t>>::assign(const char32_t* first, const char32_t* last)```</span>.
    pub unsafe fn assign_2_char32_t(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_assign1(
            self as *mut crate::VectorOfChar32T,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(last)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```char32_t& std::vector<char32_t, std::allocator<char32_t>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::cpp_core::char32_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_at(
                self as *mut crate::VectorOfChar32T,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char32_t& std::vector<char32_t, std::allocator<char32_t>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::cpp_core::char32_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_at1(
                self as *const crate::VectorOfChar32T,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char32_t& std::vector<char32_t, std::allocator<char32_t>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::cpp_core::char32_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_back(
                self as *mut crate::VectorOfChar32T,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char32_t& std::vector<char32_t, std::allocator<char32_t>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::cpp_core::char32_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_back1(
                self as *const crate::VectorOfChar32T,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<char32_t, std::allocator<char32_t>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_capacity(
            self as *const crate::VectorOfChar32T,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char32_t, std::allocator<char32_t>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_clear(
            self as *mut crate::VectorOfChar32T,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<char32_t, std::allocator<char32_t>>& std::vector<char32_t, std::allocator<char32_t>>::operator=(const std::vector<char32_t, std::allocator<char32_t>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfChar32T>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfChar32T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_operator_(
                self as *mut crate::VectorOfChar32T,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfChar32T>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char32_t* std::vector<char32_t, std::allocator<char32_t>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::cpp_core::char32_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_data(
                self as *mut crate::VectorOfChar32T,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const char32_t* std::vector<char32_t, std::allocator<char32_t>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::cpp_core::char32_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_data1(
                self as *const crate::VectorOfChar32T,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<char32_t, std::allocator<char32_t>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_empty(
            self as *const crate::VectorOfChar32T,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```char32_t& std::vector<char32_t, std::allocator<char32_t>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::cpp_core::char32_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_front(
                self as *mut crate::VectorOfChar32T,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char32_t& std::vector<char32_t, std::allocator<char32_t>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::cpp_core::char32_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_front1(
                self as *const crate::VectorOfChar32T,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```char32_t& std::vector<char32_t, std::allocator<char32_t>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::cpp_core::char32_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_operator__(
                self as *mut crate::VectorOfChar32T,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const char32_t& std::vector<char32_t, std::allocator<char32_t>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::cpp_core::char32_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_operator__1(
                self as *const crate::VectorOfChar32T,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<char32_t, std::allocator<char32_t>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_max_size(
            self as *const crate::VectorOfChar32T,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char32_t, std::allocator<char32_t>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfChar32T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char32_t, std::allocator<char32_t>>::vector(const std::allocator<char32_t>& __a)```</span>.
    pub unsafe fn from_allocator_of_char32_t(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar32T>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar32T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar32T>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char32_t, std::allocator<char32_t>>::vector(size_t __n, const std::allocator<char32_t>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_char32_t(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar32T>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar32T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar32T>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char32_t, std::allocator<char32_t>>::vector(size_t __n, const char32_t& __value, const std::allocator<char32_t>& __a = …)```</span>.
    pub unsafe fn from_usize_char32_t_allocator_of_char32_t(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::cpp_core::char32_t>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar32T>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar32T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_vector4(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<::cpp_core::char32_t>>::cast_into(value)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar32T>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char32_t, std::allocator<char32_t>>::vector(const std::vector<char32_t, std::allocator<char32_t>>& __x, const std::allocator<char32_t>& __a)```</span>.
    pub unsafe fn from_vector_of_char32_t_allocator_of_char32_t(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfChar32T>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar32T>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar32T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfChar32T>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar32T>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char32_t, std::allocator<char32_t>>::vector(const char32_t* first, const char32_t* last, std::allocator<char32_t> alloc = …)```</span>.
    pub unsafe fn from_2_char32_t_allocator_of_char32_t(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfChar32T>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar32T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_vector8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(first)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(last)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfChar32T>>::cast_into(
                    alloc,
                )
                .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char32_t, std::allocator<char32_t>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfChar32T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char32_t, std::allocator<char32_t>>::vector(size_t __n, const char32_t& __value)```</span>.
    pub unsafe fn from_usize_char32_t(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::cpp_core::char32_t>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar32T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<::cpp_core::char32_t>>::cast_into(value)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char32_t, std::allocator<char32_t>>::vector(const char32_t* first, const char32_t* last)```</span>.
    pub unsafe fn from_2_char32_t(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar32T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(first)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(last)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<char32_t, std::allocator<char32_t>>::vector(const std::vector<char32_t, std::allocator<char32_t>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfChar32T>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfChar32T> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfChar32T>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char32_t, std::allocator<char32_t>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_pop_back(
            self as *mut crate::VectorOfChar32T,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char32_t, std::allocator<char32_t>>::push_back(const char32_t& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::cpp_core::char32_t>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_push_back(
            self as *mut crate::VectorOfChar32T,
            ::cpp_core::CastInto::<::cpp_core::Ref<::cpp_core::char32_t>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char32_t, std::allocator<char32_t>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_reserve(
            self as *mut crate::VectorOfChar32T,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char32_t, std::allocator<char32_t>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_resize(
            self as *mut crate::VectorOfChar32T,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char32_t, std::allocator<char32_t>>::resize(size_t __new_size, const char32_t& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::cpp_core::char32_t>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_resize1(
            self as *mut crate::VectorOfChar32T,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<::cpp_core::char32_t>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char32_t, std::allocator<char32_t>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_shrink_to_fit(
            self as *mut crate::VectorOfChar32T,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<char32_t, std::allocator<char32_t>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_size(
            self as *const crate::VectorOfChar32T,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<char32_t, std::allocator<char32_t>>::swap(std::vector<char32_t, std::allocator<char32_t>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfChar32T>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_swap(
            self as *mut crate::VectorOfChar32T,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfChar32T>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<short, std::allocator<short>>```</span>.
#[repr(C)]
pub struct VectorOfShort {
    _unused: u8,
}
impl VectorOfShort {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<short, std::allocator<short>>::assign(size_t __n, const short& __val)```</span>.
    pub unsafe fn assign_usize_short(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_short>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_assign(
            self as *mut crate::VectorOfShort,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_short>>::cast_into(val)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<short, std::allocator<short>>::assign(const short* first, const short* last)```</span>.
    pub unsafe fn assign_2_short(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_short>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_short>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_assign1(
            self as *mut crate::VectorOfShort,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_short>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_short>>::cast_into(last)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```short& std::vector<short, std::allocator<short>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_short> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_at(
            self as *mut crate::VectorOfShort,
            n,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const short& std::vector<short, std::allocator<short>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_short> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_at1(
            self as *const crate::VectorOfShort,
            n,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```short& std::vector<short, std::allocator<short>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_short> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_back(
            self as *mut crate::VectorOfShort,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const short& std::vector<short, std::allocator<short>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::std::os::raw::c_short> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_back1(
            self as *const crate::VectorOfShort,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<short, std::allocator<short>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_capacity(
            self as *const crate::VectorOfShort,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<short, std::allocator<short>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_clear(
            self as *mut crate::VectorOfShort,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<short, std::allocator<short>>& std::vector<short, std::allocator<short>>::operator=(const std::vector<short, std::allocator<short>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfShort>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfShort> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_operator_(
                self as *mut crate::VectorOfShort,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfShort>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```short* std::vector<short, std::allocator<short>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_short> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_data(
            self as *mut crate::VectorOfShort,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const short* std::vector<short, std::allocator<short>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_short> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_data1(
            self as *const crate::VectorOfShort,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<short, std::allocator<short>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_empty(
            self as *const crate::VectorOfShort,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```short& std::vector<short, std::allocator<short>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_short> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_front(
            self as *mut crate::VectorOfShort,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const short& std::vector<short, std::allocator<short>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::std::os::raw::c_short> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_front1(
            self as *const crate::VectorOfShort,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```short& std::vector<short, std::allocator<short>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_short> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_operator__(
                self as *mut crate::VectorOfShort,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const short& std::vector<short, std::allocator<short>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_short> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_operator__1(
                self as *const crate::VectorOfShort,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<short, std::allocator<short>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_max_size(
            self as *const crate::VectorOfShort,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<short, std::allocator<short>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfShort> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<short, std::allocator<short>>::vector(const std::allocator<short>& __a)```</span>.
    pub unsafe fn from_allocator_of_short(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfShort>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfShort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_vector2(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfShort>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<short, std::allocator<short>>::vector(size_t __n, const std::allocator<short>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_short(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfShort>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfShort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_vector3(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfShort>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<short, std::allocator<short>>::vector(size_t __n, const short& __value, const std::allocator<short>& __a = …)```</span>.
    pub unsafe fn from_usize_short_allocator_of_short(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_short>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfShort>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfShort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_vector4(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_short>>::cast_into(value)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfShort>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<short, std::allocator<short>>::vector(const std::vector<short, std::allocator<short>>& __x, const std::allocator<short>& __a)```</span>.
    pub unsafe fn from_vector_of_short_allocator_of_short(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfShort>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfShort>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfShort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_vector6(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfShort>>::cast_into(x)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfShort>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<short, std::allocator<short>>::vector(const short* first, const short* last, std::allocator<short> alloc = …)```</span>.
    pub unsafe fn from_2_short_allocator_of_short(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_short>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_short>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfShort>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfShort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_vector8(
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_short>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_short>>::cast_into(last)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfShort>>::cast_into(alloc)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<short, std::allocator<short>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfShort> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<short, std::allocator<short>>::vector(size_t __n, const short& __value)```</span>.
    pub unsafe fn from_usize_short(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_short>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfShort> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_short>>::cast_into(value)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<short, std::allocator<short>>::vector(const short* first, const short* last)```</span>.
    pub unsafe fn from_2_short(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_short>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_short>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfShort> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_short>>::cast_into(first)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_short>>::cast_into(last)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<short, std::allocator<short>>::vector(const std::vector<short, std::allocator<short>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfShort>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfShort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_vector1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfShort>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<short, std::allocator<short>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_pop_back(
            self as *mut crate::VectorOfShort,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<short, std::allocator<short>>::push_back(const short& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_short>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_push_back(
            self as *mut crate::VectorOfShort,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_short>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<short, std::allocator<short>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_reserve(
            self as *mut crate::VectorOfShort,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<short, std::allocator<short>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_resize(
            self as *mut crate::VectorOfShort,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<short, std::allocator<short>>::resize(size_t __new_size, const short& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_short>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_resize1(
            self as *mut crate::VectorOfShort,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_short>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<short, std::allocator<short>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_shrink_to_fit(
            self as *mut crate::VectorOfShort,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<short, std::allocator<short>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_size(
            self as *const crate::VectorOfShort,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<short, std::allocator<short>>::swap(std::vector<short, std::allocator<short>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfShort>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_swap(
            self as *mut crate::VectorOfShort,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfShort>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<unsigned short, std::allocator<unsigned short>>```</span>.
#[repr(C)]
pub struct VectorOfUshort {
    _unused: u8,
}
impl VectorOfUshort {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned short, std::allocator<unsigned short>>::assign(size_t __n, const unsigned short& __val)```</span>.
    pub unsafe fn assign_usize_ushort(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_ushort>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_assign(
            self as *mut crate::VectorOfUshort,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_ushort>>::cast_into(val)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned short, std::allocator<unsigned short>>::assign(const unsigned short* first, const unsigned short* last)```</span>.
    pub unsafe fn assign_2_ushort(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ushort>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ushort>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_assign1(
            self as *mut crate::VectorOfUshort,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ushort>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ushort>>::cast_into(last)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned short& std::vector<unsigned short, std::allocator<unsigned short>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_ushort> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_at(
                self as *mut crate::VectorOfUshort,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned short& std::vector<unsigned short, std::allocator<unsigned short>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_ushort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_at1(self as *const crate::VectorOfUshort, n);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned short& std::vector<unsigned short, std::allocator<unsigned short>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_ushort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_back(self as *mut crate::VectorOfUshort);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned short& std::vector<unsigned short, std::allocator<unsigned short>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::std::os::raw::c_ushort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_back1(self as *const crate::VectorOfUshort);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned short, std::allocator<unsigned short>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_capacity(self as *const crate::VectorOfUshort)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned short, std::allocator<unsigned short>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_clear(
            self as *mut crate::VectorOfUshort,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<unsigned short, std::allocator<unsigned short>>& std::vector<unsigned short, std::allocator<unsigned short>>::operator=(const std::vector<unsigned short, std::allocator<unsigned short>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUshort>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfUshort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_operator_(self as *mut crate::VectorOfUshort, ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUshort>>::cast_into(other).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned short* std::vector<unsigned short, std::allocator<unsigned short>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_ushort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_data(self as *mut crate::VectorOfUshort);
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned short* std::vector<unsigned short, std::allocator<unsigned short>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_ushort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_data1(self as *const crate::VectorOfUshort);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<unsigned short, std::allocator<unsigned short>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_empty(
            self as *const crate::VectorOfUshort,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned short& std::vector<unsigned short, std::allocator<unsigned short>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_ushort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_front(self as *mut crate::VectorOfUshort);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned short& std::vector<unsigned short, std::allocator<unsigned short>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::std::os::raw::c_ushort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_front1(self as *const crate::VectorOfUshort);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned short& std::vector<unsigned short, std::allocator<unsigned short>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_ushort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_operator__(self as *mut crate::VectorOfUshort, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned short& std::vector<unsigned short, std::allocator<unsigned short>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_ushort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_operator__1(self as *const crate::VectorOfUshort, n);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned short, std::allocator<unsigned short>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_max_size(self as *const crate::VectorOfUshort)
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned short, std::allocator<unsigned short>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfUshort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned short, std::allocator<unsigned short>>::vector(const std::allocator<unsigned short>& __a)```</span>.
    pub unsafe fn from_allocator_of_ushort(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUshort>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUshort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_vector2(::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUshort>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned short, std::allocator<unsigned short>>::vector(size_t __n, const std::allocator<unsigned short>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_ushort(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUshort>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUshort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_vector3(n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUshort>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned short, std::allocator<unsigned short>>::vector(size_t __n, const unsigned short& __value, const std::allocator<unsigned short>& __a = …)```</span>.
    pub unsafe fn from_usize_ushort_allocator_of_ushort(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_ushort>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUshort>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUshort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_vector4(n, ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_ushort>>::cast_into(value).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUshort>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned short, std::allocator<unsigned short>>::vector(const std::vector<unsigned short, std::allocator<unsigned short>>& __x, const std::allocator<unsigned short>& __a)```</span>.
    pub unsafe fn from_vector_of_ushort_allocator_of_ushort(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUshort>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUshort>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUshort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_vector6(::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUshort>>::cast_into(x).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUshort>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned short, std::allocator<unsigned short>>::vector(const unsigned short* first, const unsigned short* last, std::allocator<unsigned short> alloc = …)```</span>.
    pub unsafe fn from_2_ushort_allocator_of_ushort(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ushort>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ushort>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUshort>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUshort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_vector8(::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ushort>>::cast_into(first).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ushort>>::cast_into(last).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUshort>>::cast_into(alloc).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned short, std::allocator<unsigned short>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfUshort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned short, std::allocator<unsigned short>>::vector(size_t __n, const unsigned short& __value)```</span>.
    pub unsafe fn from_usize_ushort(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_ushort>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUshort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_vector10(n, ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_ushort>>::cast_into(value).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned short, std::allocator<unsigned short>>::vector(const unsigned short* first, const unsigned short* last)```</span>.
    pub unsafe fn from_2_ushort(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ushort>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ushort>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUshort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_vector11(::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ushort>>::cast_into(first).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ushort>>::cast_into(last).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned short, std::allocator<unsigned short>>::vector(const std::vector<unsigned short, std::allocator<unsigned short>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUshort>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUshort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_vector1(::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUshort>>::cast_into(other).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned short, std::allocator<unsigned short>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_pop_back(self as *mut crate::VectorOfUshort)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned short, std::allocator<unsigned short>>::push_back(const unsigned short& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_ushort>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_push_back(self as *mut crate::VectorOfUshort, ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_ushort>>::cast_into(x).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned short, std::allocator<unsigned short>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_reserve(
            self as *mut crate::VectorOfUshort,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned short, std::allocator<unsigned short>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_resize(
            self as *mut crate::VectorOfUshort,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned short, std::allocator<unsigned short>>::resize(size_t __new_size, const unsigned short& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_ushort>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_resize1(
            self as *mut crate::VectorOfUshort,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_ushort>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned short, std::allocator<unsigned short>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_shrink_to_fit(self as *mut crate::VectorOfUshort)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned short, std::allocator<unsigned short>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_size(
            self as *const crate::VectorOfUshort,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned short, std::allocator<unsigned short>>::swap(std::vector<unsigned short, std::allocator<unsigned short>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUshort>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_swap(
            self as *mut crate::VectorOfUshort,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUshort>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<int, std::allocator<int>>```</span>.
#[repr(C)]
pub struct VectorOfInt {
    _unused: u8,
}
impl VectorOfInt {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<int, std::allocator<int>>::assign(size_t __n, const int& __val)```</span>.
    pub unsafe fn assign_usize_int(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_int>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_assign(
            self as *mut crate::VectorOfInt,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_int>>::cast_into(val)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int, std::allocator<int>>::assign(const int* first, const int* last)```</span>.
    pub unsafe fn assign_2_int(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_int>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_int>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_assign1(
            self as *mut crate::VectorOfInt,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_int>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_int>>::cast_into(last)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```int& std::vector<int, std::allocator<int>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_int> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_at(
            self as *mut crate::VectorOfInt,
            n,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int& std::vector<int, std::allocator<int>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_int> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_at1(
            self as *const crate::VectorOfInt,
            n,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```int& std::vector<int, std::allocator<int>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_int> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_back(
            self as *mut crate::VectorOfInt,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int& std::vector<int, std::allocator<int>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::std::os::raw::c_int> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_back1(
            self as *const crate::VectorOfInt,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int, std::allocator<int>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_capacity(
            self as *const crate::VectorOfInt,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int, std::allocator<int>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_clear(
            self as *mut crate::VectorOfInt,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<int, std::allocator<int>>& std::vector<int, std::allocator<int>>::operator=(const std::vector<int, std::allocator<int>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfInt>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfInt> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_operator_(
            self as *mut crate::VectorOfInt,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfInt>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```int* std::vector<int, std::allocator<int>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_int> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_data(
            self as *mut crate::VectorOfInt,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const int* std::vector<int, std::allocator<int>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_int> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_data1(
            self as *const crate::VectorOfInt,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<int, std::allocator<int>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_empty(
            self as *const crate::VectorOfInt,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```int& std::vector<int, std::allocator<int>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_int> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_front(
            self as *mut crate::VectorOfInt,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int& std::vector<int, std::allocator<int>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::std::os::raw::c_int> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_front1(
            self as *const crate::VectorOfInt,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```int& std::vector<int, std::allocator<int>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_int> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_operator__(
            self as *mut crate::VectorOfInt,
            n,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int& std::vector<int, std::allocator<int>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_int> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_operator__1(
            self as *const crate::VectorOfInt,
            n,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int, std::allocator<int>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_max_size(
            self as *const crate::VectorOfInt,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int, std::allocator<int>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfInt> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int, std::allocator<int>>::vector(const std::allocator<int>& __a)```</span>.
    pub unsafe fn from_allocator_of_int(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfInt>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfInt> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_vector2(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfInt>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int, std::allocator<int>>::vector(size_t __n, const std::allocator<int>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_int(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfInt>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfInt> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_vector3(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfInt>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int, std::allocator<int>>::vector(size_t __n, const int& __value, const std::allocator<int>& __a = …)```</span>.
    pub unsafe fn from_usize_int_allocator_of_int(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_int>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfInt>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfInt> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_vector4(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_int>>::cast_into(value)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfInt>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int, std::allocator<int>>::vector(const std::vector<int, std::allocator<int>>& __x, const std::allocator<int>& __a)```</span>.
    pub unsafe fn from_vector_of_int_allocator_of_int(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfInt>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfInt>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfInt> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_vector6(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfInt>>::cast_into(x).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfInt>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int, std::allocator<int>>::vector(const int* first, const int* last, std::allocator<int> alloc = …)```</span>.
    pub unsafe fn from_2_int_allocator_of_int(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_int>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_int>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfInt>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfInt> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_vector8(
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_int>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_int>>::cast_into(last)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfInt>>::cast_into(alloc)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int, std::allocator<int>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfInt> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int, std::allocator<int>>::vector(size_t __n, const int& __value)```</span>.
    pub unsafe fn from_usize_int(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_int>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfInt> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_vector10(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_int>>::cast_into(value)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int, std::allocator<int>>::vector(const int* first, const int* last)```</span>.
    pub unsafe fn from_2_int(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_int>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_int>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfInt> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_vector11(
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_int>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_int>>::cast_into(last)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int, std::allocator<int>>::vector(const std::vector<int, std::allocator<int>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfInt>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfInt> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_vector1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfInt>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int, std::allocator<int>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_pop_back(
            self as *mut crate::VectorOfInt,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int, std::allocator<int>>::push_back(const int& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_int>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_push_back(
            self as *mut crate::VectorOfInt,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_int>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int, std::allocator<int>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_reserve(
            self as *mut crate::VectorOfInt,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int, std::allocator<int>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_resize(
            self as *mut crate::VectorOfInt,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int, std::allocator<int>>::resize(size_t __new_size, const int& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_int>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_resize1(
            self as *mut crate::VectorOfInt,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_int>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int, std::allocator<int>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_shrink_to_fit(
            self as *mut crate::VectorOfInt,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int, std::allocator<int>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_size(
            self as *const crate::VectorOfInt,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int, std::allocator<int>>::swap(std::vector<int, std::allocator<int>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfInt>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_swap(
            self as *mut crate::VectorOfInt,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfInt>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<unsigned int, std::allocator<unsigned int>>```</span>.
#[repr(C)]
pub struct VectorOfUint {
    _unused: u8,
}
impl VectorOfUint {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned int, std::allocator<unsigned int>>::assign(size_t __n, const unsigned int& __val)```</span>.
    pub unsafe fn assign_usize_uint(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_uint>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_assign(
            self as *mut crate::VectorOfUint,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_uint>>::cast_into(val)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned int, std::allocator<unsigned int>>::assign(const unsigned int* first, const unsigned int* last)```</span>.
    pub unsafe fn assign_2_uint(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_uint>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_uint>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_assign1(
            self as *mut crate::VectorOfUint,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_uint>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_uint>>::cast_into(last)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned int& std::vector<unsigned int, std::allocator<unsigned int>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_uint> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_at(
                self as *mut crate::VectorOfUint,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned int& std::vector<unsigned int, std::allocator<unsigned int>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_uint> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_at1(
                self as *const crate::VectorOfUint,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned int& std::vector<unsigned int, std::allocator<unsigned int>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_uint> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_back(
                self as *mut crate::VectorOfUint,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned int& std::vector<unsigned int, std::allocator<unsigned int>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::std::os::raw::c_uint> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_back1(
                self as *const crate::VectorOfUint,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned int, std::allocator<unsigned int>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_capacity(
            self as *const crate::VectorOfUint,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned int, std::allocator<unsigned int>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_clear(
            self as *mut crate::VectorOfUint,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<unsigned int, std::allocator<unsigned int>>& std::vector<unsigned int, std::allocator<unsigned int>>::operator=(const std::vector<unsigned int, std::allocator<unsigned int>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUint>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfUint> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_operator_(self as *mut crate::VectorOfUint, ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUint>>::cast_into(other).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned int* std::vector<unsigned int, std::allocator<unsigned int>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_uint> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_data(
                self as *mut crate::VectorOfUint,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned int* std::vector<unsigned int, std::allocator<unsigned int>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_uint> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_data1(
                self as *const crate::VectorOfUint,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<unsigned int, std::allocator<unsigned int>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_empty(
            self as *const crate::VectorOfUint,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned int& std::vector<unsigned int, std::allocator<unsigned int>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_uint> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_front(
                self as *mut crate::VectorOfUint,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned int& std::vector<unsigned int, std::allocator<unsigned int>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::std::os::raw::c_uint> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_front1(
                self as *const crate::VectorOfUint,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned int& std::vector<unsigned int, std::allocator<unsigned int>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_uint> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_operator__(self as *mut crate::VectorOfUint, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned int& std::vector<unsigned int, std::allocator<unsigned int>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_uint> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_operator__1(self as *const crate::VectorOfUint, n);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned int, std::allocator<unsigned int>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_max_size(
            self as *const crate::VectorOfUint,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned int, std::allocator<unsigned int>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfUint> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_vector(
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned int, std::allocator<unsigned int>>::vector(const std::allocator<unsigned int>& __a)```</span>.
    pub unsafe fn from_allocator_of_uint(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUint>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUint> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_vector2(::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUint>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned int, std::allocator<unsigned int>>::vector(size_t __n, const std::allocator<unsigned int>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_uint(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUint>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUint> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_vector3(n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUint>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned int, std::allocator<unsigned int>>::vector(size_t __n, const unsigned int& __value, const std::allocator<unsigned int>& __a = …)```</span>.
    pub unsafe fn from_usize_uint_allocator_of_uint(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_uint>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUint>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUint> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_vector4(n, ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_uint>>::cast_into(value).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUint>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned int, std::allocator<unsigned int>>::vector(const std::vector<unsigned int, std::allocator<unsigned int>>& __x, const std::allocator<unsigned int>& __a)```</span>.
    pub unsafe fn from_vector_of_uint_allocator_of_uint(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUint>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUint>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUint> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_vector6(::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUint>>::cast_into(x).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUint>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned int, std::allocator<unsigned int>>::vector(const unsigned int* first, const unsigned int* last, std::allocator<unsigned int> alloc = …)```</span>.
    pub unsafe fn from_2_uint_allocator_of_uint(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_uint>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_uint>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUint>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUint> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_vector8(::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_uint>>::cast_into(first).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_uint>>::cast_into(last).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUint>>::cast_into(alloc).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned int, std::allocator<unsigned int>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfUint> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned int, std::allocator<unsigned int>>::vector(size_t __n, const unsigned int& __value)```</span>.
    pub unsafe fn from_usize_uint(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_uint>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUint> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_vector10(n, ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_uint>>::cast_into(value).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned int, std::allocator<unsigned int>>::vector(const unsigned int* first, const unsigned int* last)```</span>.
    pub unsafe fn from_2_uint(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_uint>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_uint>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUint> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_vector11(::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_uint>>::cast_into(first).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_uint>>::cast_into(last).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned int, std::allocator<unsigned int>>::vector(const std::vector<unsigned int, std::allocator<unsigned int>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUint>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUint> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_vector1(::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUint>>::cast_into(other).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned int, std::allocator<unsigned int>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_pop_back(
            self as *mut crate::VectorOfUint,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned int, std::allocator<unsigned int>>::push_back(const unsigned int& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_uint>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_push_back(
            self as *mut crate::VectorOfUint,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_uint>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned int, std::allocator<unsigned int>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_reserve(
            self as *mut crate::VectorOfUint,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned int, std::allocator<unsigned int>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_resize(
            self as *mut crate::VectorOfUint,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned int, std::allocator<unsigned int>>::resize(size_t __new_size, const unsigned int& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_uint>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_resize1(
            self as *mut crate::VectorOfUint,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_uint>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned int, std::allocator<unsigned int>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_shrink_to_fit(self as *mut crate::VectorOfUint)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned int, std::allocator<unsigned int>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_size(
            self as *const crate::VectorOfUint,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned int, std::allocator<unsigned int>>::swap(std::vector<unsigned int, std::allocator<unsigned int>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUint>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_swap(
            self as *mut crate::VectorOfUint,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUint>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<long, std::allocator<long>>```</span>.
#[repr(C)]
pub struct VectorOfLong {
    _unused: u8,
}
impl VectorOfLong {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<long, std::allocator<long>>::assign(size_t __n, const long& __val)```</span>.
    pub unsafe fn assign_usize_long(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_long>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_assign(
            self as *mut crate::VectorOfLong,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_long>>::cast_into(val)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long, std::allocator<long>>::assign(const long* first, const long* last)```</span>.
    pub unsafe fn assign_2_long(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_long>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_long>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_assign1(
            self as *mut crate::VectorOfLong,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_long>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_long>>::cast_into(last)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```long& std::vector<long, std::allocator<long>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_long> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_at(
            self as *mut crate::VectorOfLong,
            n,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const long& std::vector<long, std::allocator<long>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_long> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_at1(
            self as *const crate::VectorOfLong,
            n,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```long& std::vector<long, std::allocator<long>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_long> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_back(
            self as *mut crate::VectorOfLong,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const long& std::vector<long, std::allocator<long>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::std::os::raw::c_long> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_back1(
            self as *const crate::VectorOfLong,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<long, std::allocator<long>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_capacity(
            self as *const crate::VectorOfLong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long, std::allocator<long>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_clear(
            self as *mut crate::VectorOfLong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<long, std::allocator<long>>& std::vector<long, std::allocator<long>>::operator=(const std::vector<long, std::allocator<long>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfLong>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfLong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_operator_(
            self as *mut crate::VectorOfLong,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfLong>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```long* std::vector<long, std::allocator<long>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_long> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_data(
            self as *mut crate::VectorOfLong,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const long* std::vector<long, std::allocator<long>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_long> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_data1(
            self as *const crate::VectorOfLong,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<long, std::allocator<long>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_empty(
            self as *const crate::VectorOfLong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```long& std::vector<long, std::allocator<long>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_long> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_front(
            self as *mut crate::VectorOfLong,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const long& std::vector<long, std::allocator<long>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::std::os::raw::c_long> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_front1(
            self as *const crate::VectorOfLong,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```long& std::vector<long, std::allocator<long>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_long> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_operator__(
                self as *mut crate::VectorOfLong,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const long& std::vector<long, std::allocator<long>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_long> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_operator__1(
                self as *const crate::VectorOfLong,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<long, std::allocator<long>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_max_size(
            self as *const crate::VectorOfLong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long, std::allocator<long>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfLong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long, std::allocator<long>>::vector(const std::allocator<long>& __a)```</span>.
    pub unsafe fn from_allocator_of_long(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfLong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_vector2(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfLong>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long, std::allocator<long>>::vector(size_t __n, const std::allocator<long>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_long(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfLong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_vector3(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfLong>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long, std::allocator<long>>::vector(size_t __n, const long& __value, const std::allocator<long>& __a = …)```</span>.
    pub unsafe fn from_usize_long_allocator_of_long(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_long>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfLong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_vector4(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_long>>::cast_into(value)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfLong>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long, std::allocator<long>>::vector(const std::vector<long, std::allocator<long>>& __x, const std::allocator<long>& __a)```</span>.
    pub unsafe fn from_vector_of_long_allocator_of_long(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfLong>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfLong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_vector6(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfLong>>::cast_into(x).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfLong>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long, std::allocator<long>>::vector(const long* first, const long* last, std::allocator<long> alloc = …)```</span>.
    pub unsafe fn from_2_long_allocator_of_long(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_long>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_long>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfLong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_vector8(
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_long>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_long>>::cast_into(last)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfLong>>::cast_into(alloc)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long, std::allocator<long>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfLong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long, std::allocator<long>>::vector(size_t __n, const long& __value)```</span>.
    pub unsafe fn from_usize_long(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_long>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_vector10(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_long>>::cast_into(value)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long, std::allocator<long>>::vector(const long* first, const long* last)```</span>.
    pub unsafe fn from_2_long(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_long>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_long>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_vector11(
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_long>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_long>>::cast_into(last)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long, std::allocator<long>>::vector(const std::vector<long, std::allocator<long>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfLong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_vector1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfLong>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long, std::allocator<long>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_pop_back(
            self as *mut crate::VectorOfLong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long, std::allocator<long>>::push_back(const long& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_long>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_push_back(
            self as *mut crate::VectorOfLong,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_long>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long, std::allocator<long>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_reserve(
            self as *mut crate::VectorOfLong,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long, std::allocator<long>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_resize(
            self as *mut crate::VectorOfLong,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long, std::allocator<long>>::resize(size_t __new_size, const long& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_long>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_resize1(
            self as *mut crate::VectorOfLong,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_long>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long, std::allocator<long>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_shrink_to_fit(
            self as *mut crate::VectorOfLong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<long, std::allocator<long>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_size(
            self as *const crate::VectorOfLong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long, std::allocator<long>>::swap(std::vector<long, std::allocator<long>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfLong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_swap(
            self as *mut crate::VectorOfLong,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfLong>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<unsigned long, std::allocator<unsigned long>>```</span>.
#[repr(C)]
pub struct VectorOfUlong {
    _unused: u8,
}
impl VectorOfUlong {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long, std::allocator<unsigned long>>::assign(size_t __n, const unsigned long& __val)```</span>.
    pub unsafe fn assign_usize_ulong(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_ulong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_assign(
            self as *mut crate::VectorOfUlong,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_ulong>>::cast_into(val)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long, std::allocator<unsigned long>>::assign(const unsigned long* first, const unsigned long* last)```</span>.
    pub unsafe fn assign_2_ulong(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ulong>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ulong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_assign1(
            self as *mut crate::VectorOfUlong,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ulong>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ulong>>::cast_into(last)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned long& std::vector<unsigned long, std::allocator<unsigned long>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_ulong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_at(
                self as *mut crate::VectorOfUlong,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned long& std::vector<unsigned long, std::allocator<unsigned long>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_ulong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_at1(
                self as *const crate::VectorOfUlong,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned long& std::vector<unsigned long, std::allocator<unsigned long>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_ulong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_back(
                self as *mut crate::VectorOfUlong,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned long& std::vector<unsigned long, std::allocator<unsigned long>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::std::os::raw::c_ulong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_back1(self as *const crate::VectorOfUlong);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned long, std::allocator<unsigned long>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_capacity(
            self as *const crate::VectorOfUlong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long, std::allocator<unsigned long>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_clear(
            self as *mut crate::VectorOfUlong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<unsigned long, std::allocator<unsigned long>>& std::vector<unsigned long, std::allocator<unsigned long>>::operator=(const std::vector<unsigned long, std::allocator<unsigned long>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUlong>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfUlong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_operator_(self as *mut crate::VectorOfUlong, ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUlong>>::cast_into(other).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned long* std::vector<unsigned long, std::allocator<unsigned long>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_ulong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_data(
                self as *mut crate::VectorOfUlong,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned long* std::vector<unsigned long, std::allocator<unsigned long>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_ulong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_data1(self as *const crate::VectorOfUlong);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<unsigned long, std::allocator<unsigned long>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_empty(
            self as *const crate::VectorOfUlong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned long& std::vector<unsigned long, std::allocator<unsigned long>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_ulong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_front(self as *mut crate::VectorOfUlong);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned long& std::vector<unsigned long, std::allocator<unsigned long>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::std::os::raw::c_ulong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_front1(self as *const crate::VectorOfUlong);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned long& std::vector<unsigned long, std::allocator<unsigned long>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_ulong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_operator__(self as *mut crate::VectorOfUlong, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned long& std::vector<unsigned long, std::allocator<unsigned long>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_ulong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_operator__1(self as *const crate::VectorOfUlong, n);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned long, std::allocator<unsigned long>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_max_size(
            self as *const crate::VectorOfUlong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long, std::allocator<unsigned long>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfUlong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long, std::allocator<unsigned long>>::vector(const std::allocator<unsigned long>& __a)```</span>.
    pub unsafe fn from_allocator_of_ulong(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUlong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_vector2(::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUlong>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long, std::allocator<unsigned long>>::vector(size_t __n, const std::allocator<unsigned long>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_ulong(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUlong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_vector3(n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUlong>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long, std::allocator<unsigned long>>::vector(size_t __n, const unsigned long& __value, const std::allocator<unsigned long>& __a = …)```</span>.
    pub unsafe fn from_usize_ulong_allocator_of_ulong(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_ulong>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUlong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_vector4(n, ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_ulong>>::cast_into(value).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUlong>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long, std::allocator<unsigned long>>::vector(const std::vector<unsigned long, std::allocator<unsigned long>>& __x, const std::allocator<unsigned long>& __a)```</span>.
    pub unsafe fn from_vector_of_ulong_allocator_of_ulong(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUlong>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUlong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_vector6(::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUlong>>::cast_into(x).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUlong>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long, std::allocator<unsigned long>>::vector(const unsigned long* first, const unsigned long* last, std::allocator<unsigned long> alloc = …)```</span>.
    pub unsafe fn from_2_ulong_allocator_of_ulong(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ulong>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ulong>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUlong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_vector8(::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ulong>>::cast_into(first).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ulong>>::cast_into(last).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUlong>>::cast_into(alloc).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long, std::allocator<unsigned long>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfUlong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long, std::allocator<unsigned long>>::vector(size_t __n, const unsigned long& __value)```</span>.
    pub unsafe fn from_usize_ulong(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_ulong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_vector10(n, ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_ulong>>::cast_into(value).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long, std::allocator<unsigned long>>::vector(const unsigned long* first, const unsigned long* last)```</span>.
    pub unsafe fn from_2_ulong(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ulong>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ulong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_vector11(::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ulong>>::cast_into(first).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ulong>>::cast_into(last).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long, std::allocator<unsigned long>>::vector(const std::vector<unsigned long, std::allocator<unsigned long>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUlong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_vector1(::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUlong>>::cast_into(other).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long, std::allocator<unsigned long>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_pop_back(
            self as *mut crate::VectorOfUlong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long, std::allocator<unsigned long>>::push_back(const unsigned long& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_ulong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_push_back(
            self as *mut crate::VectorOfUlong,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_ulong>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long, std::allocator<unsigned long>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_reserve(
            self as *mut crate::VectorOfUlong,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long, std::allocator<unsigned long>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_resize(
            self as *mut crate::VectorOfUlong,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long, std::allocator<unsigned long>>::resize(size_t __new_size, const unsigned long& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_ulong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_resize1(
            self as *mut crate::VectorOfUlong,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_ulong>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long, std::allocator<unsigned long>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_shrink_to_fit(self as *mut crate::VectorOfUlong)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned long, std::allocator<unsigned long>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_size(
            self as *const crate::VectorOfUlong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long, std::allocator<unsigned long>>::swap(std::vector<unsigned long, std::allocator<unsigned long>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUlong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_swap(
            self as *mut crate::VectorOfUlong,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUlong>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<long long, std::allocator<long long>>```</span>.
#[repr(C)]
pub struct VectorOfLonglong {
    _unused: u8,
}
impl VectorOfLonglong {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<long long, std::allocator<long long>>::assign(size_t __n, const long long& __val)```</span>.
    pub unsafe fn assign_usize_longlong(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_longlong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_assign(
            self as *mut crate::VectorOfLonglong,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_longlong>>::cast_into(val)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long long, std::allocator<long long>>::assign(const long long* first, const long long* last)```</span>.
    pub unsafe fn assign_2_longlong(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_longlong>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_longlong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_assign1(
            self as *mut crate::VectorOfLonglong,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_longlong>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_longlong>>::cast_into(last)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```long long& std::vector<long long, std::allocator<long long>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_longlong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_at(
                self as *mut crate::VectorOfLonglong,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const long long& std::vector<long long, std::allocator<long long>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_longlong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_at1(
                self as *const crate::VectorOfLonglong,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```long long& std::vector<long long, std::allocator<long long>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_longlong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_back(
                self as *mut crate::VectorOfLonglong,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const long long& std::vector<long long, std::allocator<long long>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::std::os::raw::c_longlong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_back1(
                self as *const crate::VectorOfLonglong,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<long long, std::allocator<long long>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_capacity(
            self as *const crate::VectorOfLonglong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long long, std::allocator<long long>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_clear(
            self as *mut crate::VectorOfLonglong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<long long, std::allocator<long long>>& std::vector<long long, std::allocator<long long>>::operator=(const std::vector<long long, std::allocator<long long>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfLonglong>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfLonglong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_operator_(
                self as *mut crate::VectorOfLonglong,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfLonglong>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```long long* std::vector<long long, std::allocator<long long>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_longlong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_data(
                self as *mut crate::VectorOfLonglong,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const long long* std::vector<long long, std::allocator<long long>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_longlong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_data1(
                self as *const crate::VectorOfLonglong,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<long long, std::allocator<long long>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_empty(
            self as *const crate::VectorOfLonglong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```long long& std::vector<long long, std::allocator<long long>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_longlong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_front(
                self as *mut crate::VectorOfLonglong,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const long long& std::vector<long long, std::allocator<long long>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::std::os::raw::c_longlong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_front1(
                self as *const crate::VectorOfLonglong,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```long long& std::vector<long long, std::allocator<long long>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_longlong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_operator__(
                self as *mut crate::VectorOfLonglong,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const long long& std::vector<long long, std::allocator<long long>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_longlong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_operator__1(
                self as *const crate::VectorOfLonglong,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<long long, std::allocator<long long>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_max_size(
            self as *const crate::VectorOfLonglong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long long, std::allocator<long long>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfLonglong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long long, std::allocator<long long>>::vector(const std::allocator<long long>& __a)```</span>.
    pub unsafe fn from_allocator_of_longlong(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfLonglong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLonglong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfLonglong>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long long, std::allocator<long long>>::vector(size_t __n, const std::allocator<long long>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_longlong(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfLonglong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLonglong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfLonglong>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long long, std::allocator<long long>>::vector(size_t __n, const long long& __value, const std::allocator<long long>& __a = …)```</span>.
    pub unsafe fn from_usize_longlong_allocator_of_longlong(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_longlong>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfLonglong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLonglong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_vector4(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_longlong>>::cast_into(
                    value,
                )
                .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfLonglong>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long long, std::allocator<long long>>::vector(const std::vector<long long, std::allocator<long long>>& __x, const std::allocator<long long>& __a)```</span>.
    pub unsafe fn from_vector_of_longlong_allocator_of_longlong(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfLonglong>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfLonglong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLonglong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfLonglong>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfLonglong>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long long, std::allocator<long long>>::vector(const long long* first, const long long* last, std::allocator<long long> alloc = …)```</span>.
    pub unsafe fn from_2_longlong_allocator_of_longlong(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_longlong>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_longlong>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfLonglong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLonglong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_vector8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_longlong>>::cast_into(
                    first,
                )
                .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_longlong>>::cast_into(
                    last,
                )
                .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfLonglong>>::cast_into(
                    alloc,
                )
                .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long long, std::allocator<long long>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfLonglong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long long, std::allocator<long long>>::vector(size_t __n, const long long& __value)```</span>.
    pub unsafe fn from_usize_longlong(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_longlong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLonglong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_longlong>>::cast_into(
                    value,
                )
                .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long long, std::allocator<long long>>::vector(const long long* first, const long long* last)```</span>.
    pub unsafe fn from_2_longlong(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_longlong>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_longlong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLonglong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_longlong>>::cast_into(
                    first,
                )
                .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_longlong>>::cast_into(
                    last,
                )
                .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<long long, std::allocator<long long>>::vector(const std::vector<long long, std::allocator<long long>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfLonglong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfLonglong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfLonglong>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long long, std::allocator<long long>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_pop_back(
            self as *mut crate::VectorOfLonglong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long long, std::allocator<long long>>::push_back(const long long& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_longlong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_push_back(
            self as *mut crate::VectorOfLonglong,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_longlong>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long long, std::allocator<long long>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_reserve(
            self as *mut crate::VectorOfLonglong,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long long, std::allocator<long long>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_resize(
            self as *mut crate::VectorOfLonglong,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long long, std::allocator<long long>>::resize(size_t __new_size, const long long& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_longlong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_resize1(
            self as *mut crate::VectorOfLonglong,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_longlong>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long long, std::allocator<long long>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_shrink_to_fit(
            self as *mut crate::VectorOfLonglong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<long long, std::allocator<long long>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_size(
            self as *const crate::VectorOfLonglong,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<long long, std::allocator<long long>>::swap(std::vector<long long, std::allocator<long long>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfLonglong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_swap(
            self as *mut crate::VectorOfLonglong,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfLonglong>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<unsigned long long, std::allocator<unsigned long long>>```</span>.
#[repr(C)]
pub struct VectorOfUlonglong {
    _unused: u8,
}
impl VectorOfUlonglong {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long long, std::allocator<unsigned long long>>::assign(size_t __n, const unsigned long long& __val)```</span>.
    pub unsafe fn assign_usize_ulonglong(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_ulonglong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_assign(self as *mut crate::VectorOfUlonglong, n, ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_ulonglong>>::cast_into(val).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long long, std::allocator<unsigned long long>>::assign(const unsigned long long* first, const unsigned long long* last)```</span>.
    pub unsafe fn assign_2_ulonglong(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ulonglong>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ulonglong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_assign1(self as *mut crate::VectorOfUlonglong, ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ulonglong>>::cast_into(first).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ulonglong>>::cast_into(last).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned long long& std::vector<unsigned long long, std::allocator<unsigned long long>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_ulonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_at(self as *mut crate::VectorOfUlonglong, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned long long& std::vector<unsigned long long, std::allocator<unsigned long long>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_ulonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_at1(self as *const crate::VectorOfUlonglong, n);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned long long& std::vector<unsigned long long, std::allocator<unsigned long long>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_ulonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_back(self as *mut crate::VectorOfUlonglong);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned long long& std::vector<unsigned long long, std::allocator<unsigned long long>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::std::os::raw::c_ulonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_back1(self as *const crate::VectorOfUlonglong);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned long long, std::allocator<unsigned long long>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_capacity(self as *const crate::VectorOfUlonglong)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long long, std::allocator<unsigned long long>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_clear(self as *mut crate::VectorOfUlonglong)
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<unsigned long long, std::allocator<unsigned long long>>& std::vector<unsigned long long, std::allocator<unsigned long long>>::operator=(const std::vector<unsigned long long, std::allocator<unsigned long long>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUlonglong>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfUlonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_operator_(self as *mut crate::VectorOfUlonglong, ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUlonglong>>::cast_into(other).as_raw_ptr());
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned long long* std::vector<unsigned long long, std::allocator<unsigned long long>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_ulonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_data(self as *mut crate::VectorOfUlonglong);
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned long long* std::vector<unsigned long long, std::allocator<unsigned long long>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_ulonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_data1(self as *const crate::VectorOfUlonglong);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<unsigned long long, std::allocator<unsigned long long>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_empty(self as *const crate::VectorOfUlonglong)
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned long long& std::vector<unsigned long long, std::allocator<unsigned long long>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_ulonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_front(self as *mut crate::VectorOfUlonglong);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned long long& std::vector<unsigned long long, std::allocator<unsigned long long>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::std::os::raw::c_ulonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_front1(self as *const crate::VectorOfUlonglong);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```unsigned long long& std::vector<unsigned long long, std::allocator<unsigned long long>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(
        &mut self,
        n: usize,
    ) -> ::cpp_core::MutRef<::std::os::raw::c_ulonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_operator__(self as *mut crate::VectorOfUlonglong, n);
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const unsigned long long& std::vector<unsigned long long, std::allocator<unsigned long long>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_ulonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_operator__1(self as *const crate::VectorOfUlonglong, n);
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned long long, std::allocator<unsigned long long>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_max_size(self as *const crate::VectorOfUlonglong)
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long long, std::allocator<unsigned long long>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfUlonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long long, std::allocator<unsigned long long>>::vector(const std::allocator<unsigned long long>& __a)```</span>.
    pub unsafe fn from_allocator_of_ulonglong(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUlonglong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_vector2(::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUlonglong>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long long, std::allocator<unsigned long long>>::vector(size_t __n, const std::allocator<unsigned long long>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_ulonglong(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUlonglong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_vector3(n, ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUlonglong>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long long, std::allocator<unsigned long long>>::vector(size_t __n, const unsigned long long& __value, const std::allocator<unsigned long long>& __a = …)```</span>.
    pub unsafe fn from_usize_ulonglong_allocator_of_ulonglong(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_ulonglong>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUlonglong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_vector4(n, ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_ulonglong>>::cast_into(value).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUlonglong>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long long, std::allocator<unsigned long long>>::vector(const std::vector<unsigned long long, std::allocator<unsigned long long>>& __x, const std::allocator<unsigned long long>& __a)```</span>.
    pub unsafe fn from_vector_of_ulonglong_allocator_of_ulonglong(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUlonglong>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUlonglong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_vector6(::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUlonglong>>::cast_into(x).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUlonglong>>::cast_into(a).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long long, std::allocator<unsigned long long>>::vector(const unsigned long long* first, const unsigned long long* last, std::allocator<unsigned long long> alloc = …)```</span>.
    pub unsafe fn from_2_ulonglong_allocator_of_ulonglong(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ulonglong>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ulonglong>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUlonglong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_vector8(::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ulonglong>>::cast_into(first).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ulonglong>>::cast_into(last).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUlonglong>>::cast_into(alloc).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long long, std::allocator<unsigned long long>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfUlonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long long, std::allocator<unsigned long long>>::vector(size_t __n, const unsigned long long& __value)```</span>.
    pub unsafe fn from_usize_ulonglong(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_ulonglong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_vector10(n, ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_ulonglong>>::cast_into(value).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long long, std::allocator<unsigned long long>>::vector(const unsigned long long* first, const unsigned long long* last)```</span>.
    pub unsafe fn from_2_ulonglong(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ulonglong>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_ulonglong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_vector11(::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ulonglong>>::cast_into(first).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_ulonglong>>::cast_into(last).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<unsigned long long, std::allocator<unsigned long long>>::vector(const std::vector<unsigned long long, std::allocator<unsigned long long>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUlonglong>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUlonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_vector1(::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUlonglong>>::cast_into(other).as_raw_ptr());
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long long, std::allocator<unsigned long long>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_pop_back(self as *mut crate::VectorOfUlonglong)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long long, std::allocator<unsigned long long>>::push_back(const unsigned long long& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_ulonglong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_push_back(self as *mut crate::VectorOfUlonglong, ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_ulonglong>>::cast_into(x).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long long, std::allocator<unsigned long long>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_reserve(self as *mut crate::VectorOfUlonglong, n)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long long, std::allocator<unsigned long long>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_resize(self as *mut crate::VectorOfUlonglong, new_size)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long long, std::allocator<unsigned long long>>::resize(size_t __new_size, const unsigned long long& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_ulonglong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_resize1(self as *mut crate::VectorOfUlonglong, new_size, ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_ulonglong>>::cast_into(x).as_raw_ptr())
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long long, std::allocator<unsigned long long>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_shrink_to_fit(self as *mut crate::VectorOfUlonglong)
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned long long, std::allocator<unsigned long long>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_size(self as *const crate::VectorOfUlonglong)
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<unsigned long long, std::allocator<unsigned long long>>::swap(std::vector<unsigned long long, std::allocator<unsigned long long>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUlonglong>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_swap(self as *mut crate::VectorOfUlonglong, ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUlonglong>>::cast_into(x).as_mut_raw_ptr())
    }
}

/// C++ class: <span style='color: green;'>```std::vector<float, std::allocator<float>>```</span>.
#[repr(C)]
pub struct VectorOfFloat {
    _unused: u8,
}
impl VectorOfFloat {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<float, std::allocator<float>>::assign(size_t __n, const float& __val)```</span>.
    pub unsafe fn assign_usize_float(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_float>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_assign(
            self as *mut crate::VectorOfFloat,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_float>>::cast_into(val)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<float, std::allocator<float>>::assign(const float* first, const float* last)```</span>.
    pub unsafe fn assign_2_float(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_float>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_float>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_assign1(
            self as *mut crate::VectorOfFloat,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_float>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_float>>::cast_into(last)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```float& std::vector<float, std::allocator<float>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_float> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_at(
            self as *mut crate::VectorOfFloat,
            n,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const float& std::vector<float, std::allocator<float>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_float> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_at1(
            self as *const crate::VectorOfFloat,
            n,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```float& std::vector<float, std::allocator<float>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_float> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_back(
            self as *mut crate::VectorOfFloat,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const float& std::vector<float, std::allocator<float>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::std::os::raw::c_float> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_back1(
            self as *const crate::VectorOfFloat,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<float, std::allocator<float>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_capacity(
            self as *const crate::VectorOfFloat,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<float, std::allocator<float>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_clear(
            self as *mut crate::VectorOfFloat,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<float, std::allocator<float>>& std::vector<float, std::allocator<float>>::operator=(const std::vector<float, std::allocator<float>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfFloat>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfFloat> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_operator_(
                self as *mut crate::VectorOfFloat,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfFloat>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```float* std::vector<float, std::allocator<float>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_float> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_data(
            self as *mut crate::VectorOfFloat,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const float* std::vector<float, std::allocator<float>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_float> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_data1(
            self as *const crate::VectorOfFloat,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<float, std::allocator<float>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_empty(
            self as *const crate::VectorOfFloat,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```float& std::vector<float, std::allocator<float>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_float> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_front(
            self as *mut crate::VectorOfFloat,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const float& std::vector<float, std::allocator<float>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::std::os::raw::c_float> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_front1(
            self as *const crate::VectorOfFloat,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```float& std::vector<float, std::allocator<float>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_float> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_operator__(
                self as *mut crate::VectorOfFloat,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const float& std::vector<float, std::allocator<float>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_float> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_operator__1(
                self as *const crate::VectorOfFloat,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<float, std::allocator<float>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_max_size(
            self as *const crate::VectorOfFloat,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<float, std::allocator<float>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfFloat> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<float, std::allocator<float>>::vector(const std::allocator<float>& __a)```</span>.
    pub unsafe fn from_allocator_of_float(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfFloat>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfFloat> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_vector2(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfFloat>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<float, std::allocator<float>>::vector(size_t __n, const std::allocator<float>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_float(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfFloat>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfFloat> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_vector3(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfFloat>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<float, std::allocator<float>>::vector(size_t __n, const float& __value, const std::allocator<float>& __a = …)```</span>.
    pub unsafe fn from_usize_float_allocator_of_float(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_float>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfFloat>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfFloat> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_vector4(
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_float>>::cast_into(value)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfFloat>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<float, std::allocator<float>>::vector(const std::vector<float, std::allocator<float>>& __x, const std::allocator<float>& __a)```</span>.
    pub unsafe fn from_vector_of_float_allocator_of_float(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfFloat>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfFloat>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfFloat> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_vector6(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfFloat>>::cast_into(x)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfFloat>>::cast_into(a)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<float, std::allocator<float>>::vector(const float* first, const float* last, std::allocator<float> alloc = …)```</span>.
    pub unsafe fn from_2_float_allocator_of_float(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_float>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_float>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfFloat>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfFloat> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_vector8(
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_float>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_float>>::cast_into(last)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfFloat>>::cast_into(alloc)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<float, std::allocator<float>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfFloat> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<float, std::allocator<float>>::vector(size_t __n, const float& __value)```</span>.
    pub unsafe fn from_usize_float(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_float>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfFloat> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_float>>::cast_into(value)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<float, std::allocator<float>>::vector(const float* first, const float* last)```</span>.
    pub unsafe fn from_2_float(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_float>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_float>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfFloat> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_float>>::cast_into(first)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_float>>::cast_into(last)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<float, std::allocator<float>>::vector(const std::vector<float, std::allocator<float>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfFloat>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfFloat> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_vector1(
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfFloat>>::cast_into(other)
                .as_raw_ptr(),
        );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<float, std::allocator<float>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_pop_back(
            self as *mut crate::VectorOfFloat,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<float, std::allocator<float>>::push_back(const float& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_float>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_push_back(
            self as *mut crate::VectorOfFloat,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_float>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<float, std::allocator<float>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_reserve(
            self as *mut crate::VectorOfFloat,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<float, std::allocator<float>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_resize(
            self as *mut crate::VectorOfFloat,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<float, std::allocator<float>>::resize(size_t __new_size, const float& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_float>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_resize1(
            self as *mut crate::VectorOfFloat,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_float>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<float, std::allocator<float>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_shrink_to_fit(
            self as *mut crate::VectorOfFloat,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<float, std::allocator<float>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_size(
            self as *const crate::VectorOfFloat,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<float, std::allocator<float>>::swap(std::vector<float, std::allocator<float>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfFloat>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_swap(
            self as *mut crate::VectorOfFloat,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfFloat>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<double, std::allocator<double>>```</span>.
#[repr(C)]
pub struct VectorOfDouble {
    _unused: u8,
}
impl VectorOfDouble {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<double, std::allocator<double>>::assign(size_t __n, const double& __val)```</span>.
    pub unsafe fn assign_usize_double(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_double>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_assign(
            self as *mut crate::VectorOfDouble,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_double>>::cast_into(val)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<double, std::allocator<double>>::assign(const double* first, const double* last)```</span>.
    pub unsafe fn assign_2_double(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_double>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_double>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_assign1(
            self as *mut crate::VectorOfDouble,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_double>>::cast_into(first)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_double>>::cast_into(last)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```double& std::vector<double, std::allocator<double>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_double> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_at(
            self as *mut crate::VectorOfDouble,
            n,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const double& std::vector<double, std::allocator<double>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_double> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_at1(
            self as *const crate::VectorOfDouble,
            n,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```double& std::vector<double, std::allocator<double>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_double> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_back(
            self as *mut crate::VectorOfDouble,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const double& std::vector<double, std::allocator<double>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<::std::os::raw::c_double> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_back1(
            self as *const crate::VectorOfDouble,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<double, std::allocator<double>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_capacity(
            self as *const crate::VectorOfDouble,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<double, std::allocator<double>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_clear(
            self as *mut crate::VectorOfDouble,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<double, std::allocator<double>>& std::vector<double, std::allocator<double>>::operator=(const std::vector<double, std::allocator<double>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfDouble>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfDouble> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_operator_(
                self as *mut crate::VectorOfDouble,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfDouble>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```double* std::vector<double, std::allocator<double>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_double> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_data(
            self as *mut crate::VectorOfDouble,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const double* std::vector<double, std::allocator<double>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_double> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_data1(
            self as *const crate::VectorOfDouble,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<double, std::allocator<double>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_empty(
            self as *const crate::VectorOfDouble,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```double& std::vector<double, std::allocator<double>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<::std::os::raw::c_double> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_front(
            self as *mut crate::VectorOfDouble,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const double& std::vector<double, std::allocator<double>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<::std::os::raw::c_double> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_front1(
                self as *const crate::VectorOfDouble,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```double& std::vector<double, std::allocator<double>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<::std::os::raw::c_double> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_operator__(
                self as *mut crate::VectorOfDouble,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const double& std::vector<double, std::allocator<double>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<::std::os::raw::c_double> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_operator__1(
                self as *const crate::VectorOfDouble,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<double, std::allocator<double>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_max_size(
            self as *const crate::VectorOfDouble,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<double, std::allocator<double>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfDouble> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<double, std::allocator<double>>::vector(const std::allocator<double>& __a)```</span>.
    pub unsafe fn from_allocator_of_double(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfDouble>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfDouble> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfDouble>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<double, std::allocator<double>>::vector(size_t __n, const std::allocator<double>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_double(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfDouble>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfDouble> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfDouble>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<double, std::allocator<double>>::vector(size_t __n, const double& __value, const std::allocator<double>& __a = …)```</span>.
    pub unsafe fn from_usize_double_allocator_of_double(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_double>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfDouble>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfDouble> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_vector4(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_double>>::cast_into(value)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfDouble>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<double, std::allocator<double>>::vector(const std::vector<double, std::allocator<double>>& __x, const std::allocator<double>& __a)```</span>.
    pub unsafe fn from_vector_of_double_allocator_of_double(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfDouble>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfDouble>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfDouble> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfDouble>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfDouble>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<double, std::allocator<double>>::vector(const double* first, const double* last, std::allocator<double> alloc = …)```</span>.
    pub unsafe fn from_2_double_allocator_of_double(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_double>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_double>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfDouble>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfDouble> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_vector8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_double>>::cast_into(first)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_double>>::cast_into(last)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfDouble>>::cast_into(alloc)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<double, std::allocator<double>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfDouble> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<double, std::allocator<double>>::vector(size_t __n, const double& __value)```</span>.
    pub unsafe fn from_usize_double(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_double>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfDouble> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_double>>::cast_into(value)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<double, std::allocator<double>>::vector(const double* first, const double* last)```</span>.
    pub unsafe fn from_2_double(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_double>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_double>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfDouble> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_double>>::cast_into(first)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_double>>::cast_into(last)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<double, std::allocator<double>>::vector(const std::vector<double, std::allocator<double>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfDouble>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfDouble> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfDouble>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<double, std::allocator<double>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_pop_back(
            self as *mut crate::VectorOfDouble,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<double, std::allocator<double>>::push_back(const double& __x)```</span>.
    pub unsafe fn push_back(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_double>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_push_back(
            self as *mut crate::VectorOfDouble,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_double>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<double, std::allocator<double>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_reserve(
            self as *mut crate::VectorOfDouble,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<double, std::allocator<double>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_resize(
            self as *mut crate::VectorOfDouble,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<double, std::allocator<double>>::resize(size_t __new_size, const double& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<::std::os::raw::c_double>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_resize1(
            self as *mut crate::VectorOfDouble,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<::std::os::raw::c_double>>::cast_into(x)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<double, std::allocator<double>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_shrink_to_fit(
            self as *mut crate::VectorOfDouble,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<double, std::allocator<double>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_size(
            self as *const crate::VectorOfDouble,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<double, std::allocator<double>>::swap(std::vector<double, std::allocator<double>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfDouble>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_swap(
            self as *mut crate::VectorOfDouble,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfDouble>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<int8_t, std::allocator<int8_t>>```</span>.
#[repr(C)]
pub struct VectorOfI8 {
    _unused: u8,
}
impl VectorOfI8 {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<int8_t, std::allocator<int8_t>>::assign(size_t __n, const int8_t& __val)```</span>.
    pub unsafe fn assign_usize_i8(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<i8>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_assign(
            self as *mut crate::VectorOfI8,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<i8>>::cast_into(val).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int8_t, std::allocator<int8_t>>::assign(const int8_t* first, const int8_t* last)```</span>.
    pub unsafe fn assign_2_i8(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<i8>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<i8>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_assign1(
            self as *mut crate::VectorOfI8,
            ::cpp_core::CastInto::<::cpp_core::Ptr<i8>>::cast_into(first).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<i8>>::cast_into(last).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```int8_t& std::vector<int8_t, std::allocator<int8_t>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<i8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_at(
            self as *mut crate::VectorOfI8,
            n,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int8_t& std::vector<int8_t, std::allocator<int8_t>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<i8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_at1(
            self as *const crate::VectorOfI8,
            n,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```int8_t& std::vector<int8_t, std::allocator<int8_t>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<i8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_back(
            self as *mut crate::VectorOfI8,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int8_t& std::vector<int8_t, std::allocator<int8_t>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<i8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_back1(
            self as *const crate::VectorOfI8,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int8_t, std::allocator<int8_t>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_capacity(
            self as *const crate::VectorOfI8,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int8_t, std::allocator<int8_t>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_clear(
            self as *mut crate::VectorOfI8,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<int8_t, std::allocator<int8_t>>& std::vector<int8_t, std::allocator<int8_t>>::operator=(const std::vector<int8_t, std::allocator<int8_t>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfI8>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfI8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_operator_(
                self as *mut crate::VectorOfI8,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfI8>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```int8_t* std::vector<int8_t, std::allocator<int8_t>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<i8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_data(
            self as *mut crate::VectorOfI8,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const int8_t* std::vector<int8_t, std::allocator<int8_t>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<i8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_data1(
            self as *const crate::VectorOfI8,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<int8_t, std::allocator<int8_t>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_empty(
            self as *const crate::VectorOfI8,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```int8_t& std::vector<int8_t, std::allocator<int8_t>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<i8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_front(
            self as *mut crate::VectorOfI8,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int8_t& std::vector<int8_t, std::allocator<int8_t>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<i8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_front1(
                self as *const crate::VectorOfI8,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```int8_t& std::vector<int8_t, std::allocator<int8_t>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<i8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_operator__(
                self as *mut crate::VectorOfI8,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int8_t& std::vector<int8_t, std::allocator<int8_t>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<i8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_operator__1(
                self as *const crate::VectorOfI8,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int8_t, std::allocator<int8_t>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_max_size(
            self as *const crate::VectorOfI8,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int8_t, std::allocator<int8_t>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfI8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int8_t, std::allocator<int8_t>>::vector(const std::allocator<int8_t>& __a)```</span>.
    pub unsafe fn from_allocator_of_i8(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI8>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int8_t, std::allocator<int8_t>>::vector(size_t __n, const std::allocator<int8_t>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_i8(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI8>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int8_t, std::allocator<int8_t>>::vector(size_t __n, const int8_t& __value, const std::allocator<int8_t>& __a = …)```</span>.
    pub unsafe fn from_usize_i8_allocator_of_i8(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<i8>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_vector4(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<i8>>::cast_into(value).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI8>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int8_t, std::allocator<int8_t>>::vector(const std::vector<int8_t, std::allocator<int8_t>>& __x, const std::allocator<int8_t>& __a)```</span>.
    pub unsafe fn from_vector_of_i8_allocator_of_i8(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfI8>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfI8>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI8>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int8_t, std::allocator<int8_t>>::vector(const int8_t* first, const int8_t* last, std::allocator<int8_t> alloc = …)```</span>.
    pub unsafe fn from_2_i8_allocator_of_i8(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<i8>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<i8>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_vector8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<i8>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<i8>>::cast_into(last).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI8>>::cast_into(alloc)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int8_t, std::allocator<int8_t>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfI8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int8_t, std::allocator<int8_t>>::vector(size_t __n, const int8_t& __value)```</span>.
    pub unsafe fn from_usize_i8(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<i8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<i8>>::cast_into(value).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int8_t, std::allocator<int8_t>>::vector(const int8_t* first, const int8_t* last)```</span>.
    pub unsafe fn from_2_i8(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<i8>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<i8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<i8>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<i8>>::cast_into(last).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int8_t, std::allocator<int8_t>>::vector(const std::vector<int8_t, std::allocator<int8_t>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfI8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfI8>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int8_t, std::allocator<int8_t>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_pop_back(
            self as *mut crate::VectorOfI8,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int8_t, std::allocator<int8_t>>::push_back(const int8_t& __x)```</span>.
    pub unsafe fn push_back(&mut self, x: impl ::cpp_core::CastInto<::cpp_core::Ref<i8>>) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_push_back(
            self as *mut crate::VectorOfI8,
            ::cpp_core::CastInto::<::cpp_core::Ref<i8>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int8_t, std::allocator<int8_t>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_reserve(
            self as *mut crate::VectorOfI8,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int8_t, std::allocator<int8_t>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_resize(
            self as *mut crate::VectorOfI8,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int8_t, std::allocator<int8_t>>::resize(size_t __new_size, const int8_t& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<i8>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_resize1(
            self as *mut crate::VectorOfI8,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<i8>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int8_t, std::allocator<int8_t>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_shrink_to_fit(
            self as *mut crate::VectorOfI8,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int8_t, std::allocator<int8_t>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_size(
            self as *const crate::VectorOfI8,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int8_t, std::allocator<int8_t>>::swap(std::vector<int8_t, std::allocator<int8_t>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfI8>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_swap(
            self as *mut crate::VectorOfI8,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfI8>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<uint8_t, std::allocator<uint8_t>>```</span>.
#[repr(C)]
pub struct VectorOfU8 {
    _unused: u8,
}
impl VectorOfU8 {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint8_t, std::allocator<uint8_t>>::assign(size_t __n, const uint8_t& __val)```</span>.
    pub unsafe fn assign_usize_u8(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<u8>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_assign(
            self as *mut crate::VectorOfU8,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<u8>>::cast_into(val).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint8_t, std::allocator<uint8_t>>::assign(const uint8_t* first, const uint8_t* last)```</span>.
    pub unsafe fn assign_2_u8(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<u8>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<u8>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_assign1(
            self as *mut crate::VectorOfU8,
            ::cpp_core::CastInto::<::cpp_core::Ptr<u8>>::cast_into(first).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<u8>>::cast_into(last).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```uint8_t& std::vector<uint8_t, std::allocator<uint8_t>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<u8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_at(
            self as *mut crate::VectorOfU8,
            n,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint8_t& std::vector<uint8_t, std::allocator<uint8_t>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<u8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_at1(
            self as *const crate::VectorOfU8,
            n,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```uint8_t& std::vector<uint8_t, std::allocator<uint8_t>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<u8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_back(
                self as *mut crate::VectorOfU8,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint8_t& std::vector<uint8_t, std::allocator<uint8_t>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<u8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_back1(
                self as *const crate::VectorOfU8,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint8_t, std::allocator<uint8_t>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_capacity(
            self as *const crate::VectorOfU8,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint8_t, std::allocator<uint8_t>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_clear(
            self as *mut crate::VectorOfU8,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<uint8_t, std::allocator<uint8_t>>& std::vector<uint8_t, std::allocator<uint8_t>>::operator=(const std::vector<uint8_t, std::allocator<uint8_t>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfU8>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfU8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_operator_(
                self as *mut crate::VectorOfU8,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfU8>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```uint8_t* std::vector<uint8_t, std::allocator<uint8_t>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<u8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_data(
                self as *mut crate::VectorOfU8,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const uint8_t* std::vector<uint8_t, std::allocator<uint8_t>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<u8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_data1(
                self as *const crate::VectorOfU8,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<uint8_t, std::allocator<uint8_t>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_empty(
            self as *const crate::VectorOfU8,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```uint8_t& std::vector<uint8_t, std::allocator<uint8_t>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<u8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_front(
                self as *mut crate::VectorOfU8,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint8_t& std::vector<uint8_t, std::allocator<uint8_t>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<u8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_front1(
                self as *const crate::VectorOfU8,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```uint8_t& std::vector<uint8_t, std::allocator<uint8_t>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<u8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_operator__(
                self as *mut crate::VectorOfU8,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint8_t& std::vector<uint8_t, std::allocator<uint8_t>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<u8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_operator__1(
                self as *const crate::VectorOfU8,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint8_t, std::allocator<uint8_t>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_max_size(
            self as *const crate::VectorOfU8,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint8_t, std::allocator<uint8_t>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfU8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint8_t, std::allocator<uint8_t>>::vector(const std::allocator<uint8_t>& __a)```</span>.
    pub unsafe fn from_allocator_of_u8(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU8>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint8_t, std::allocator<uint8_t>>::vector(size_t __n, const std::allocator<uint8_t>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_u8(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU8>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint8_t, std::allocator<uint8_t>>::vector(size_t __n, const uint8_t& __value, const std::allocator<uint8_t>& __a = …)```</span>.
    pub unsafe fn from_usize_u8_allocator_of_u8(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<u8>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_vector4(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<u8>>::cast_into(value).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU8>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint8_t, std::allocator<uint8_t>>::vector(const std::vector<uint8_t, std::allocator<uint8_t>>& __x, const std::allocator<uint8_t>& __a)```</span>.
    pub unsafe fn from_vector_of_u8_allocator_of_u8(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfU8>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfU8>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU8>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint8_t, std::allocator<uint8_t>>::vector(const uint8_t* first, const uint8_t* last, std::allocator<uint8_t> alloc = …)```</span>.
    pub unsafe fn from_2_u8_allocator_of_u8(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<u8>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<u8>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_vector8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<u8>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<u8>>::cast_into(last).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU8>>::cast_into(alloc)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint8_t, std::allocator<uint8_t>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfU8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint8_t, std::allocator<uint8_t>>::vector(size_t __n, const uint8_t& __value)```</span>.
    pub unsafe fn from_usize_u8(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<u8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<u8>>::cast_into(value).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint8_t, std::allocator<uint8_t>>::vector(const uint8_t* first, const uint8_t* last)```</span>.
    pub unsafe fn from_2_u8(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<u8>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<u8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<u8>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<u8>>::cast_into(last).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint8_t, std::allocator<uint8_t>>::vector(const std::vector<uint8_t, std::allocator<uint8_t>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfU8>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfU8>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint8_t, std::allocator<uint8_t>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_pop_back(
            self as *mut crate::VectorOfU8,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint8_t, std::allocator<uint8_t>>::push_back(const uint8_t& __x)```</span>.
    pub unsafe fn push_back(&mut self, x: impl ::cpp_core::CastInto<::cpp_core::Ref<u8>>) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_push_back(
            self as *mut crate::VectorOfU8,
            ::cpp_core::CastInto::<::cpp_core::Ref<u8>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint8_t, std::allocator<uint8_t>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_reserve(
            self as *mut crate::VectorOfU8,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint8_t, std::allocator<uint8_t>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_resize(
            self as *mut crate::VectorOfU8,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint8_t, std::allocator<uint8_t>>::resize(size_t __new_size, const uint8_t& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<u8>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_resize1(
            self as *mut crate::VectorOfU8,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<u8>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint8_t, std::allocator<uint8_t>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_shrink_to_fit(
            self as *mut crate::VectorOfU8,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint8_t, std::allocator<uint8_t>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_size(
            self as *const crate::VectorOfU8,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint8_t, std::allocator<uint8_t>>::swap(std::vector<uint8_t, std::allocator<uint8_t>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfU8>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_swap(
            self as *mut crate::VectorOfU8,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfU8>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<int16_t, std::allocator<int16_t>>```</span>.
#[repr(C)]
pub struct VectorOfI16 {
    _unused: u8,
}
impl VectorOfI16 {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<int16_t, std::allocator<int16_t>>::assign(size_t __n, const int16_t& __val)```</span>.
    pub unsafe fn assign_usize_i16(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<i16>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_assign(
            self as *mut crate::VectorOfI16,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<i16>>::cast_into(val).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int16_t, std::allocator<int16_t>>::assign(const int16_t* first, const int16_t* last)```</span>.
    pub unsafe fn assign_2_i16(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<i16>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<i16>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_assign1(
            self as *mut crate::VectorOfI16,
            ::cpp_core::CastInto::<::cpp_core::Ptr<i16>>::cast_into(first).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<i16>>::cast_into(last).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```int16_t& std::vector<int16_t, std::allocator<int16_t>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<i16> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_at(
            self as *mut crate::VectorOfI16,
            n,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int16_t& std::vector<int16_t, std::allocator<int16_t>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<i16> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_at1(
            self as *const crate::VectorOfI16,
            n,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```int16_t& std::vector<int16_t, std::allocator<int16_t>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<i16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_back(
                self as *mut crate::VectorOfI16,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int16_t& std::vector<int16_t, std::allocator<int16_t>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<i16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_back1(
                self as *const crate::VectorOfI16,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int16_t, std::allocator<int16_t>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_capacity(
            self as *const crate::VectorOfI16,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int16_t, std::allocator<int16_t>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_clear(
            self as *mut crate::VectorOfI16,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<int16_t, std::allocator<int16_t>>& std::vector<int16_t, std::allocator<int16_t>>::operator=(const std::vector<int16_t, std::allocator<int16_t>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfI16>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfI16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_operator_(
                self as *mut crate::VectorOfI16,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfI16>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```int16_t* std::vector<int16_t, std::allocator<int16_t>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<i16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_data(
                self as *mut crate::VectorOfI16,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const int16_t* std::vector<int16_t, std::allocator<int16_t>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<i16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_data1(
                self as *const crate::VectorOfI16,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<int16_t, std::allocator<int16_t>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_empty(
            self as *const crate::VectorOfI16,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```int16_t& std::vector<int16_t, std::allocator<int16_t>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<i16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_front(
                self as *mut crate::VectorOfI16,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int16_t& std::vector<int16_t, std::allocator<int16_t>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<i16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_front1(
                self as *const crate::VectorOfI16,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```int16_t& std::vector<int16_t, std::allocator<int16_t>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<i16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_operator__(
                self as *mut crate::VectorOfI16,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int16_t& std::vector<int16_t, std::allocator<int16_t>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<i16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_operator__1(
                self as *const crate::VectorOfI16,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int16_t, std::allocator<int16_t>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_max_size(
            self as *const crate::VectorOfI16,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int16_t, std::allocator<int16_t>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfI16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int16_t, std::allocator<int16_t>>::vector(const std::allocator<int16_t>& __a)```</span>.
    pub unsafe fn from_allocator_of_i16(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI16>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int16_t, std::allocator<int16_t>>::vector(size_t __n, const std::allocator<int16_t>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_i16(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI16>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int16_t, std::allocator<int16_t>>::vector(size_t __n, const int16_t& __value, const std::allocator<int16_t>& __a = …)```</span>.
    pub unsafe fn from_usize_i16_allocator_of_i16(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<i16>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_vector4(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<i16>>::cast_into(value).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI16>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int16_t, std::allocator<int16_t>>::vector(const std::vector<int16_t, std::allocator<int16_t>>& __x, const std::allocator<int16_t>& __a)```</span>.
    pub unsafe fn from_vector_of_i16_allocator_of_i16(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfI16>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfI16>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI16>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int16_t, std::allocator<int16_t>>::vector(const int16_t* first, const int16_t* last, std::allocator<int16_t> alloc = …)```</span>.
    pub unsafe fn from_2_i16_allocator_of_i16(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<i16>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<i16>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_vector8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<i16>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<i16>>::cast_into(last).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI16>>::cast_into(alloc)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int16_t, std::allocator<int16_t>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfI16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int16_t, std::allocator<int16_t>>::vector(size_t __n, const int16_t& __value)```</span>.
    pub unsafe fn from_usize_i16(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<i16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<i16>>::cast_into(value).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int16_t, std::allocator<int16_t>>::vector(const int16_t* first, const int16_t* last)```</span>.
    pub unsafe fn from_2_i16(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<i16>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<i16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<i16>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<i16>>::cast_into(last).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int16_t, std::allocator<int16_t>>::vector(const std::vector<int16_t, std::allocator<int16_t>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfI16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfI16>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int16_t, std::allocator<int16_t>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_pop_back(
            self as *mut crate::VectorOfI16,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int16_t, std::allocator<int16_t>>::push_back(const int16_t& __x)```</span>.
    pub unsafe fn push_back(&mut self, x: impl ::cpp_core::CastInto<::cpp_core::Ref<i16>>) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_push_back(
            self as *mut crate::VectorOfI16,
            ::cpp_core::CastInto::<::cpp_core::Ref<i16>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int16_t, std::allocator<int16_t>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_reserve(
            self as *mut crate::VectorOfI16,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int16_t, std::allocator<int16_t>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_resize(
            self as *mut crate::VectorOfI16,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int16_t, std::allocator<int16_t>>::resize(size_t __new_size, const int16_t& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<i16>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_resize1(
            self as *mut crate::VectorOfI16,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<i16>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int16_t, std::allocator<int16_t>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_shrink_to_fit(
            self as *mut crate::VectorOfI16,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int16_t, std::allocator<int16_t>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_size(
            self as *const crate::VectorOfI16,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int16_t, std::allocator<int16_t>>::swap(std::vector<int16_t, std::allocator<int16_t>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfI16>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_swap(
            self as *mut crate::VectorOfI16,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfI16>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<uint16_t, std::allocator<uint16_t>>```</span>.
#[repr(C)]
pub struct VectorOfU16 {
    _unused: u8,
}
impl VectorOfU16 {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint16_t, std::allocator<uint16_t>>::assign(size_t __n, const uint16_t& __val)```</span>.
    pub unsafe fn assign_usize_u16(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<u16>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_assign(
            self as *mut crate::VectorOfU16,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<u16>>::cast_into(val).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint16_t, std::allocator<uint16_t>>::assign(const uint16_t* first, const uint16_t* last)```</span>.
    pub unsafe fn assign_2_u16(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<u16>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<u16>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_assign1(
            self as *mut crate::VectorOfU16,
            ::cpp_core::CastInto::<::cpp_core::Ptr<u16>>::cast_into(first).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<u16>>::cast_into(last).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```uint16_t& std::vector<uint16_t, std::allocator<uint16_t>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<u16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_at(
                self as *mut crate::VectorOfU16,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint16_t& std::vector<uint16_t, std::allocator<uint16_t>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<u16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_at1(
                self as *const crate::VectorOfU16,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```uint16_t& std::vector<uint16_t, std::allocator<uint16_t>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<u16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_back(
                self as *mut crate::VectorOfU16,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint16_t& std::vector<uint16_t, std::allocator<uint16_t>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<u16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_back1(
                self as *const crate::VectorOfU16,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint16_t, std::allocator<uint16_t>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_capacity(
            self as *const crate::VectorOfU16,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint16_t, std::allocator<uint16_t>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_clear(
            self as *mut crate::VectorOfU16,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<uint16_t, std::allocator<uint16_t>>& std::vector<uint16_t, std::allocator<uint16_t>>::operator=(const std::vector<uint16_t, std::allocator<uint16_t>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfU16>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfU16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_operator_(
                self as *mut crate::VectorOfU16,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfU16>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```uint16_t* std::vector<uint16_t, std::allocator<uint16_t>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<u16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_data(
                self as *mut crate::VectorOfU16,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const uint16_t* std::vector<uint16_t, std::allocator<uint16_t>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<u16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_data1(
                self as *const crate::VectorOfU16,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<uint16_t, std::allocator<uint16_t>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_empty(
            self as *const crate::VectorOfU16,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```uint16_t& std::vector<uint16_t, std::allocator<uint16_t>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<u16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_front(
                self as *mut crate::VectorOfU16,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint16_t& std::vector<uint16_t, std::allocator<uint16_t>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<u16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_front1(
                self as *const crate::VectorOfU16,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```uint16_t& std::vector<uint16_t, std::allocator<uint16_t>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<u16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_operator__(
                self as *mut crate::VectorOfU16,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint16_t& std::vector<uint16_t, std::allocator<uint16_t>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<u16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_operator__1(
                self as *const crate::VectorOfU16,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint16_t, std::allocator<uint16_t>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_max_size(
            self as *const crate::VectorOfU16,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint16_t, std::allocator<uint16_t>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfU16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint16_t, std::allocator<uint16_t>>::vector(const std::allocator<uint16_t>& __a)```</span>.
    pub unsafe fn from_allocator_of_u16(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU16>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint16_t, std::allocator<uint16_t>>::vector(size_t __n, const std::allocator<uint16_t>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_u16(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU16>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint16_t, std::allocator<uint16_t>>::vector(size_t __n, const uint16_t& __value, const std::allocator<uint16_t>& __a = …)```</span>.
    pub unsafe fn from_usize_u16_allocator_of_u16(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<u16>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_vector4(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<u16>>::cast_into(value).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU16>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint16_t, std::allocator<uint16_t>>::vector(const std::vector<uint16_t, std::allocator<uint16_t>>& __x, const std::allocator<uint16_t>& __a)```</span>.
    pub unsafe fn from_vector_of_u16_allocator_of_u16(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfU16>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfU16>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU16>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint16_t, std::allocator<uint16_t>>::vector(const uint16_t* first, const uint16_t* last, std::allocator<uint16_t> alloc = …)```</span>.
    pub unsafe fn from_2_u16_allocator_of_u16(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<u16>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<u16>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_vector8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<u16>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<u16>>::cast_into(last).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU16>>::cast_into(alloc)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint16_t, std::allocator<uint16_t>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfU16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint16_t, std::allocator<uint16_t>>::vector(size_t __n, const uint16_t& __value)```</span>.
    pub unsafe fn from_usize_u16(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<u16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<u16>>::cast_into(value).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint16_t, std::allocator<uint16_t>>::vector(const uint16_t* first, const uint16_t* last)```</span>.
    pub unsafe fn from_2_u16(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<u16>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<u16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<u16>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<u16>>::cast_into(last).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint16_t, std::allocator<uint16_t>>::vector(const std::vector<uint16_t, std::allocator<uint16_t>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfU16>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfU16>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint16_t, std::allocator<uint16_t>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_pop_back(
            self as *mut crate::VectorOfU16,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint16_t, std::allocator<uint16_t>>::push_back(const uint16_t& __x)```</span>.
    pub unsafe fn push_back(&mut self, x: impl ::cpp_core::CastInto<::cpp_core::Ref<u16>>) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_push_back(
            self as *mut crate::VectorOfU16,
            ::cpp_core::CastInto::<::cpp_core::Ref<u16>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint16_t, std::allocator<uint16_t>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_reserve(
            self as *mut crate::VectorOfU16,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint16_t, std::allocator<uint16_t>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_resize(
            self as *mut crate::VectorOfU16,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint16_t, std::allocator<uint16_t>>::resize(size_t __new_size, const uint16_t& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<u16>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_resize1(
            self as *mut crate::VectorOfU16,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<u16>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint16_t, std::allocator<uint16_t>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_shrink_to_fit(
            self as *mut crate::VectorOfU16,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint16_t, std::allocator<uint16_t>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_size(
            self as *const crate::VectorOfU16,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint16_t, std::allocator<uint16_t>>::swap(std::vector<uint16_t, std::allocator<uint16_t>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfU16>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_swap(
            self as *mut crate::VectorOfU16,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfU16>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<int32_t, std::allocator<int32_t>>```</span>.
#[repr(C)]
pub struct VectorOfI32 {
    _unused: u8,
}
impl VectorOfI32 {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<int32_t, std::allocator<int32_t>>::assign(size_t __n, const int32_t& __val)```</span>.
    pub unsafe fn assign_usize_i32(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<i32>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_assign(
            self as *mut crate::VectorOfI32,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<i32>>::cast_into(val).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int32_t, std::allocator<int32_t>>::assign(const int32_t* first, const int32_t* last)```</span>.
    pub unsafe fn assign_2_i32(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<i32>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<i32>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_assign1(
            self as *mut crate::VectorOfI32,
            ::cpp_core::CastInto::<::cpp_core::Ptr<i32>>::cast_into(first).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<i32>>::cast_into(last).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```int32_t& std::vector<int32_t, std::allocator<int32_t>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<i32> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_at(
            self as *mut crate::VectorOfI32,
            n,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int32_t& std::vector<int32_t, std::allocator<int32_t>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<i32> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_at1(
            self as *const crate::VectorOfI32,
            n,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```int32_t& std::vector<int32_t, std::allocator<int32_t>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<i32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_back(
                self as *mut crate::VectorOfI32,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int32_t& std::vector<int32_t, std::allocator<int32_t>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<i32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_back1(
                self as *const crate::VectorOfI32,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int32_t, std::allocator<int32_t>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_capacity(
            self as *const crate::VectorOfI32,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int32_t, std::allocator<int32_t>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_clear(
            self as *mut crate::VectorOfI32,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<int32_t, std::allocator<int32_t>>& std::vector<int32_t, std::allocator<int32_t>>::operator=(const std::vector<int32_t, std::allocator<int32_t>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfI32>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfI32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_operator_(
                self as *mut crate::VectorOfI32,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfI32>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```int32_t* std::vector<int32_t, std::allocator<int32_t>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<i32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_data(
                self as *mut crate::VectorOfI32,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const int32_t* std::vector<int32_t, std::allocator<int32_t>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<i32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_data1(
                self as *const crate::VectorOfI32,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<int32_t, std::allocator<int32_t>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_empty(
            self as *const crate::VectorOfI32,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```int32_t& std::vector<int32_t, std::allocator<int32_t>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<i32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_front(
                self as *mut crate::VectorOfI32,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int32_t& std::vector<int32_t, std::allocator<int32_t>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<i32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_front1(
                self as *const crate::VectorOfI32,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```int32_t& std::vector<int32_t, std::allocator<int32_t>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<i32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_operator__(
                self as *mut crate::VectorOfI32,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int32_t& std::vector<int32_t, std::allocator<int32_t>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<i32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_operator__1(
                self as *const crate::VectorOfI32,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int32_t, std::allocator<int32_t>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_max_size(
            self as *const crate::VectorOfI32,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int32_t, std::allocator<int32_t>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfI32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int32_t, std::allocator<int32_t>>::vector(const std::allocator<int32_t>& __a)```</span>.
    pub unsafe fn from_allocator_of_i32(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI32>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int32_t, std::allocator<int32_t>>::vector(size_t __n, const std::allocator<int32_t>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_i32(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI32>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int32_t, std::allocator<int32_t>>::vector(size_t __n, const int32_t& __value, const std::allocator<int32_t>& __a = …)```</span>.
    pub unsafe fn from_usize_i32_allocator_of_i32(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<i32>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_vector4(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<i32>>::cast_into(value).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI32>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int32_t, std::allocator<int32_t>>::vector(const std::vector<int32_t, std::allocator<int32_t>>& __x, const std::allocator<int32_t>& __a)```</span>.
    pub unsafe fn from_vector_of_i32_allocator_of_i32(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfI32>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfI32>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI32>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int32_t, std::allocator<int32_t>>::vector(const int32_t* first, const int32_t* last, std::allocator<int32_t> alloc = …)```</span>.
    pub unsafe fn from_2_i32_allocator_of_i32(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<i32>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<i32>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_vector8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<i32>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<i32>>::cast_into(last).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI32>>::cast_into(alloc)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int32_t, std::allocator<int32_t>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfI32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int32_t, std::allocator<int32_t>>::vector(size_t __n, const int32_t& __value)```</span>.
    pub unsafe fn from_usize_i32(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<i32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<i32>>::cast_into(value).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int32_t, std::allocator<int32_t>>::vector(const int32_t* first, const int32_t* last)```</span>.
    pub unsafe fn from_2_i32(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<i32>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<i32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<i32>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<i32>>::cast_into(last).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int32_t, std::allocator<int32_t>>::vector(const std::vector<int32_t, std::allocator<int32_t>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfI32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfI32>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int32_t, std::allocator<int32_t>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_pop_back(
            self as *mut crate::VectorOfI32,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int32_t, std::allocator<int32_t>>::push_back(const int32_t& __x)```</span>.
    pub unsafe fn push_back(&mut self, x: impl ::cpp_core::CastInto<::cpp_core::Ref<i32>>) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_push_back(
            self as *mut crate::VectorOfI32,
            ::cpp_core::CastInto::<::cpp_core::Ref<i32>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int32_t, std::allocator<int32_t>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_reserve(
            self as *mut crate::VectorOfI32,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int32_t, std::allocator<int32_t>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_resize(
            self as *mut crate::VectorOfI32,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int32_t, std::allocator<int32_t>>::resize(size_t __new_size, const int32_t& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<i32>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_resize1(
            self as *mut crate::VectorOfI32,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<i32>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int32_t, std::allocator<int32_t>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_shrink_to_fit(
            self as *mut crate::VectorOfI32,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int32_t, std::allocator<int32_t>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_size(
            self as *const crate::VectorOfI32,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int32_t, std::allocator<int32_t>>::swap(std::vector<int32_t, std::allocator<int32_t>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfI32>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_swap(
            self as *mut crate::VectorOfI32,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfI32>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<uint32_t, std::allocator<uint32_t>>```</span>.
#[repr(C)]
pub struct VectorOfU32 {
    _unused: u8,
}
impl VectorOfU32 {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint32_t, std::allocator<uint32_t>>::assign(size_t __n, const uint32_t& __val)```</span>.
    pub unsafe fn assign_usize_u32(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<u32>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_assign(
            self as *mut crate::VectorOfU32,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<u32>>::cast_into(val).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint32_t, std::allocator<uint32_t>>::assign(const uint32_t* first, const uint32_t* last)```</span>.
    pub unsafe fn assign_2_u32(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<u32>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<u32>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_assign1(
            self as *mut crate::VectorOfU32,
            ::cpp_core::CastInto::<::cpp_core::Ptr<u32>>::cast_into(first).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<u32>>::cast_into(last).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```uint32_t& std::vector<uint32_t, std::allocator<uint32_t>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<u32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_at(
                self as *mut crate::VectorOfU32,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint32_t& std::vector<uint32_t, std::allocator<uint32_t>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<u32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_at1(
                self as *const crate::VectorOfU32,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```uint32_t& std::vector<uint32_t, std::allocator<uint32_t>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<u32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_back(
                self as *mut crate::VectorOfU32,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint32_t& std::vector<uint32_t, std::allocator<uint32_t>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<u32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_back1(
                self as *const crate::VectorOfU32,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint32_t, std::allocator<uint32_t>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_capacity(
            self as *const crate::VectorOfU32,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint32_t, std::allocator<uint32_t>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_clear(
            self as *mut crate::VectorOfU32,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<uint32_t, std::allocator<uint32_t>>& std::vector<uint32_t, std::allocator<uint32_t>>::operator=(const std::vector<uint32_t, std::allocator<uint32_t>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfU32>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfU32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_operator_(
                self as *mut crate::VectorOfU32,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfU32>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```uint32_t* std::vector<uint32_t, std::allocator<uint32_t>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<u32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_data(
                self as *mut crate::VectorOfU32,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const uint32_t* std::vector<uint32_t, std::allocator<uint32_t>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<u32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_data1(
                self as *const crate::VectorOfU32,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<uint32_t, std::allocator<uint32_t>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_empty(
            self as *const crate::VectorOfU32,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```uint32_t& std::vector<uint32_t, std::allocator<uint32_t>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<u32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_front(
                self as *mut crate::VectorOfU32,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint32_t& std::vector<uint32_t, std::allocator<uint32_t>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<u32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_front1(
                self as *const crate::VectorOfU32,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```uint32_t& std::vector<uint32_t, std::allocator<uint32_t>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<u32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_operator__(
                self as *mut crate::VectorOfU32,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint32_t& std::vector<uint32_t, std::allocator<uint32_t>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<u32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_operator__1(
                self as *const crate::VectorOfU32,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint32_t, std::allocator<uint32_t>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_max_size(
            self as *const crate::VectorOfU32,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint32_t, std::allocator<uint32_t>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfU32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint32_t, std::allocator<uint32_t>>::vector(const std::allocator<uint32_t>& __a)```</span>.
    pub unsafe fn from_allocator_of_u32(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU32>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint32_t, std::allocator<uint32_t>>::vector(size_t __n, const std::allocator<uint32_t>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_u32(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU32>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint32_t, std::allocator<uint32_t>>::vector(size_t __n, const uint32_t& __value, const std::allocator<uint32_t>& __a = …)```</span>.
    pub unsafe fn from_usize_u32_allocator_of_u32(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<u32>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_vector4(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<u32>>::cast_into(value).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU32>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint32_t, std::allocator<uint32_t>>::vector(const std::vector<uint32_t, std::allocator<uint32_t>>& __x, const std::allocator<uint32_t>& __a)```</span>.
    pub unsafe fn from_vector_of_u32_allocator_of_u32(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfU32>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfU32>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU32>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint32_t, std::allocator<uint32_t>>::vector(const uint32_t* first, const uint32_t* last, std::allocator<uint32_t> alloc = …)```</span>.
    pub unsafe fn from_2_u32_allocator_of_u32(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<u32>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<u32>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_vector8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<u32>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<u32>>::cast_into(last).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU32>>::cast_into(alloc)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint32_t, std::allocator<uint32_t>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfU32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint32_t, std::allocator<uint32_t>>::vector(size_t __n, const uint32_t& __value)```</span>.
    pub unsafe fn from_usize_u32(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<u32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<u32>>::cast_into(value).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint32_t, std::allocator<uint32_t>>::vector(const uint32_t* first, const uint32_t* last)```</span>.
    pub unsafe fn from_2_u32(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<u32>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<u32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<u32>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<u32>>::cast_into(last).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint32_t, std::allocator<uint32_t>>::vector(const std::vector<uint32_t, std::allocator<uint32_t>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfU32>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfU32>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint32_t, std::allocator<uint32_t>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_pop_back(
            self as *mut crate::VectorOfU32,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint32_t, std::allocator<uint32_t>>::push_back(const uint32_t& __x)```</span>.
    pub unsafe fn push_back(&mut self, x: impl ::cpp_core::CastInto<::cpp_core::Ref<u32>>) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_push_back(
            self as *mut crate::VectorOfU32,
            ::cpp_core::CastInto::<::cpp_core::Ref<u32>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint32_t, std::allocator<uint32_t>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_reserve(
            self as *mut crate::VectorOfU32,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint32_t, std::allocator<uint32_t>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_resize(
            self as *mut crate::VectorOfU32,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint32_t, std::allocator<uint32_t>>::resize(size_t __new_size, const uint32_t& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<u32>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_resize1(
            self as *mut crate::VectorOfU32,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<u32>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint32_t, std::allocator<uint32_t>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_shrink_to_fit(
            self as *mut crate::VectorOfU32,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint32_t, std::allocator<uint32_t>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_size(
            self as *const crate::VectorOfU32,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint32_t, std::allocator<uint32_t>>::swap(std::vector<uint32_t, std::allocator<uint32_t>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfU32>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_swap(
            self as *mut crate::VectorOfU32,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfU32>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<int64_t, std::allocator<int64_t>>```</span>.
#[repr(C)]
pub struct VectorOfI64 {
    _unused: u8,
}
impl VectorOfI64 {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<int64_t, std::allocator<int64_t>>::assign(size_t __n, const int64_t& __val)```</span>.
    pub unsafe fn assign_usize_i64(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<i64>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_assign(
            self as *mut crate::VectorOfI64,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<i64>>::cast_into(val).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int64_t, std::allocator<int64_t>>::assign(const int64_t* first, const int64_t* last)```</span>.
    pub unsafe fn assign_2_i64(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<i64>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<i64>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_assign1(
            self as *mut crate::VectorOfI64,
            ::cpp_core::CastInto::<::cpp_core::Ptr<i64>>::cast_into(first).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<i64>>::cast_into(last).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```int64_t& std::vector<int64_t, std::allocator<int64_t>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<i64> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_at(
            self as *mut crate::VectorOfI64,
            n,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int64_t& std::vector<int64_t, std::allocator<int64_t>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<i64> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_at1(
            self as *const crate::VectorOfI64,
            n,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```int64_t& std::vector<int64_t, std::allocator<int64_t>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<i64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_back(
                self as *mut crate::VectorOfI64,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int64_t& std::vector<int64_t, std::allocator<int64_t>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<i64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_back1(
                self as *const crate::VectorOfI64,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int64_t, std::allocator<int64_t>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_capacity(
            self as *const crate::VectorOfI64,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int64_t, std::allocator<int64_t>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_clear(
            self as *mut crate::VectorOfI64,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<int64_t, std::allocator<int64_t>>& std::vector<int64_t, std::allocator<int64_t>>::operator=(const std::vector<int64_t, std::allocator<int64_t>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfI64>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfI64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_operator_(
                self as *mut crate::VectorOfI64,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfI64>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```int64_t* std::vector<int64_t, std::allocator<int64_t>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<i64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_data(
                self as *mut crate::VectorOfI64,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const int64_t* std::vector<int64_t, std::allocator<int64_t>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<i64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_data1(
                self as *const crate::VectorOfI64,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<int64_t, std::allocator<int64_t>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_empty(
            self as *const crate::VectorOfI64,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```int64_t& std::vector<int64_t, std::allocator<int64_t>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<i64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_front(
                self as *mut crate::VectorOfI64,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int64_t& std::vector<int64_t, std::allocator<int64_t>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<i64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_front1(
                self as *const crate::VectorOfI64,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```int64_t& std::vector<int64_t, std::allocator<int64_t>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<i64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_operator__(
                self as *mut crate::VectorOfI64,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const int64_t& std::vector<int64_t, std::allocator<int64_t>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<i64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_operator__1(
                self as *const crate::VectorOfI64,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int64_t, std::allocator<int64_t>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_max_size(
            self as *const crate::VectorOfI64,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int64_t, std::allocator<int64_t>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfI64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int64_t, std::allocator<int64_t>>::vector(const std::allocator<int64_t>& __a)```</span>.
    pub unsafe fn from_allocator_of_i64(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI64>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int64_t, std::allocator<int64_t>>::vector(size_t __n, const std::allocator<int64_t>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_i64(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI64>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int64_t, std::allocator<int64_t>>::vector(size_t __n, const int64_t& __value, const std::allocator<int64_t>& __a = …)```</span>.
    pub unsafe fn from_usize_i64_allocator_of_i64(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<i64>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_vector4(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<i64>>::cast_into(value).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI64>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int64_t, std::allocator<int64_t>>::vector(const std::vector<int64_t, std::allocator<int64_t>>& __x, const std::allocator<int64_t>& __a)```</span>.
    pub unsafe fn from_vector_of_i64_allocator_of_i64(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfI64>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfI64>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI64>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int64_t, std::allocator<int64_t>>::vector(const int64_t* first, const int64_t* last, std::allocator<int64_t> alloc = …)```</span>.
    pub unsafe fn from_2_i64_allocator_of_i64(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<i64>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<i64>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfI64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_vector8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<i64>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<i64>>::cast_into(last).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfI64>>::cast_into(alloc)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int64_t, std::allocator<int64_t>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfI64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int64_t, std::allocator<int64_t>>::vector(size_t __n, const int64_t& __value)```</span>.
    pub unsafe fn from_usize_i64(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<i64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<i64>>::cast_into(value).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int64_t, std::allocator<int64_t>>::vector(const int64_t* first, const int64_t* last)```</span>.
    pub unsafe fn from_2_i64(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<i64>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<i64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<i64>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<i64>>::cast_into(last).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<int64_t, std::allocator<int64_t>>::vector(const std::vector<int64_t, std::allocator<int64_t>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfI64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfI64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfI64>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int64_t, std::allocator<int64_t>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_pop_back(
            self as *mut crate::VectorOfI64,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int64_t, std::allocator<int64_t>>::push_back(const int64_t& __x)```</span>.
    pub unsafe fn push_back(&mut self, x: impl ::cpp_core::CastInto<::cpp_core::Ref<i64>>) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_push_back(
            self as *mut crate::VectorOfI64,
            ::cpp_core::CastInto::<::cpp_core::Ref<i64>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int64_t, std::allocator<int64_t>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_reserve(
            self as *mut crate::VectorOfI64,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int64_t, std::allocator<int64_t>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_resize(
            self as *mut crate::VectorOfI64,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int64_t, std::allocator<int64_t>>::resize(size_t __new_size, const int64_t& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<i64>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_resize1(
            self as *mut crate::VectorOfI64,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<i64>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int64_t, std::allocator<int64_t>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_shrink_to_fit(
            self as *mut crate::VectorOfI64,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int64_t, std::allocator<int64_t>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_size(
            self as *const crate::VectorOfI64,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<int64_t, std::allocator<int64_t>>::swap(std::vector<int64_t, std::allocator<int64_t>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfI64>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_swap(
            self as *mut crate::VectorOfI64,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfI64>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<uint64_t, std::allocator<uint64_t>>```</span>.
#[repr(C)]
pub struct VectorOfU64 {
    _unused: u8,
}
impl VectorOfU64 {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint64_t, std::allocator<uint64_t>>::assign(size_t __n, const uint64_t& __val)```</span>.
    pub unsafe fn assign_usize_u64(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<u64>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_assign(
            self as *mut crate::VectorOfU64,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<u64>>::cast_into(val).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint64_t, std::allocator<uint64_t>>::assign(const uint64_t* first, const uint64_t* last)```</span>.
    pub unsafe fn assign_2_u64(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<u64>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<u64>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_assign1(
            self as *mut crate::VectorOfU64,
            ::cpp_core::CastInto::<::cpp_core::Ptr<u64>>::cast_into(first).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<u64>>::cast_into(last).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```uint64_t& std::vector<uint64_t, std::allocator<uint64_t>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<u64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_at(
                self as *mut crate::VectorOfU64,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint64_t& std::vector<uint64_t, std::allocator<uint64_t>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<u64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_at1(
                self as *const crate::VectorOfU64,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```uint64_t& std::vector<uint64_t, std::allocator<uint64_t>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<u64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_back(
                self as *mut crate::VectorOfU64,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint64_t& std::vector<uint64_t, std::allocator<uint64_t>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<u64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_back1(
                self as *const crate::VectorOfU64,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint64_t, std::allocator<uint64_t>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_capacity(
            self as *const crate::VectorOfU64,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint64_t, std::allocator<uint64_t>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_clear(
            self as *mut crate::VectorOfU64,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<uint64_t, std::allocator<uint64_t>>& std::vector<uint64_t, std::allocator<uint64_t>>::operator=(const std::vector<uint64_t, std::allocator<uint64_t>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfU64>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfU64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_operator_(
                self as *mut crate::VectorOfU64,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfU64>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```uint64_t* std::vector<uint64_t, std::allocator<uint64_t>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<u64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_data(
                self as *mut crate::VectorOfU64,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const uint64_t* std::vector<uint64_t, std::allocator<uint64_t>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<u64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_data1(
                self as *const crate::VectorOfU64,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<uint64_t, std::allocator<uint64_t>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_empty(
            self as *const crate::VectorOfU64,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```uint64_t& std::vector<uint64_t, std::allocator<uint64_t>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<u64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_front(
                self as *mut crate::VectorOfU64,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint64_t& std::vector<uint64_t, std::allocator<uint64_t>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<u64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_front1(
                self as *const crate::VectorOfU64,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```uint64_t& std::vector<uint64_t, std::allocator<uint64_t>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<u64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_operator__(
                self as *mut crate::VectorOfU64,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const uint64_t& std::vector<uint64_t, std::allocator<uint64_t>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<u64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_operator__1(
                self as *const crate::VectorOfU64,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint64_t, std::allocator<uint64_t>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_max_size(
            self as *const crate::VectorOfU64,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint64_t, std::allocator<uint64_t>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfU64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint64_t, std::allocator<uint64_t>>::vector(const std::allocator<uint64_t>& __a)```</span>.
    pub unsafe fn from_allocator_of_u64(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU64>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint64_t, std::allocator<uint64_t>>::vector(size_t __n, const std::allocator<uint64_t>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_u64(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU64>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint64_t, std::allocator<uint64_t>>::vector(size_t __n, const uint64_t& __value, const std::allocator<uint64_t>& __a = …)```</span>.
    pub unsafe fn from_usize_u64_allocator_of_u64(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<u64>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_vector4(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<u64>>::cast_into(value).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU64>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint64_t, std::allocator<uint64_t>>::vector(const std::vector<uint64_t, std::allocator<uint64_t>>& __x, const std::allocator<uint64_t>& __a)```</span>.
    pub unsafe fn from_vector_of_u64_allocator_of_u64(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfU64>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfU64>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU64>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint64_t, std::allocator<uint64_t>>::vector(const uint64_t* first, const uint64_t* last, std::allocator<uint64_t> alloc = …)```</span>.
    pub unsafe fn from_2_u64_allocator_of_u64(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<u64>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<u64>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfU64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_vector8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<u64>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<u64>>::cast_into(last).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfU64>>::cast_into(alloc)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint64_t, std::allocator<uint64_t>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfU64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint64_t, std::allocator<uint64_t>>::vector(size_t __n, const uint64_t& __value)```</span>.
    pub unsafe fn from_usize_u64(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<u64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<u64>>::cast_into(value).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint64_t, std::allocator<uint64_t>>::vector(const uint64_t* first, const uint64_t* last)```</span>.
    pub unsafe fn from_2_u64(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<u64>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<u64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<u64>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<u64>>::cast_into(last).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<uint64_t, std::allocator<uint64_t>>::vector(const std::vector<uint64_t, std::allocator<uint64_t>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfU64>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfU64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfU64>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint64_t, std::allocator<uint64_t>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_pop_back(
            self as *mut crate::VectorOfU64,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint64_t, std::allocator<uint64_t>>::push_back(const uint64_t& __x)```</span>.
    pub unsafe fn push_back(&mut self, x: impl ::cpp_core::CastInto<::cpp_core::Ref<u64>>) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_push_back(
            self as *mut crate::VectorOfU64,
            ::cpp_core::CastInto::<::cpp_core::Ref<u64>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint64_t, std::allocator<uint64_t>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_reserve(
            self as *mut crate::VectorOfU64,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint64_t, std::allocator<uint64_t>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_resize(
            self as *mut crate::VectorOfU64,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint64_t, std::allocator<uint64_t>>::resize(size_t __new_size, const uint64_t& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<u64>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_resize1(
            self as *mut crate::VectorOfU64,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<u64>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint64_t, std::allocator<uint64_t>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_shrink_to_fit(
            self as *mut crate::VectorOfU64,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint64_t, std::allocator<uint64_t>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_size(
            self as *const crate::VectorOfU64,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<uint64_t, std::allocator<uint64_t>>::swap(std::vector<uint64_t, std::allocator<uint64_t>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfU64>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_swap(
            self as *mut crate::VectorOfU64,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfU64>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<size_t, std::allocator<size_t>>```</span>.
#[repr(C)]
pub struct VectorOfUsize {
    _unused: u8,
}
impl VectorOfUsize {
    /// Calls C++ function: <span style='color: green;'>```void std::vector<size_t, std::allocator<size_t>>::assign(size_t __n, const size_t& __val)```</span>.
    pub unsafe fn assign_usize_usize(
        &mut self,
        n: usize,
        val: impl ::cpp_core::CastInto<::cpp_core::Ref<usize>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_assign(
            self as *mut crate::VectorOfUsize,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<usize>>::cast_into(val).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<size_t, std::allocator<size_t>>::assign(const size_t* first, const size_t* last)```</span>.
    pub unsafe fn assign_2_usize(
        &mut self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<usize>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<usize>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_assign1(
            self as *mut crate::VectorOfUsize,
            ::cpp_core::CastInto::<::cpp_core::Ptr<usize>>::cast_into(first).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<usize>>::cast_into(last).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t& std::vector<size_t, std::allocator<size_t>>::at(size_t __n)```</span>.
    pub unsafe fn at_mut(&mut self, n: usize) -> ::cpp_core::MutRef<usize> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_at(
            self as *mut crate::VectorOfUsize,
            n,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const size_t& std::vector<size_t, std::allocator<size_t>>::at(size_t __n) const```</span>.
    pub unsafe fn at(&self, n: usize) -> ::cpp_core::Ref<usize> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_at1(
            self as *const crate::VectorOfUsize,
            n,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t& std::vector<size_t, std::allocator<size_t>>::back()```</span>.
    pub unsafe fn back_mut(&mut self) -> ::cpp_core::MutRef<usize> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_back(
            self as *mut crate::VectorOfUsize,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const size_t& std::vector<size_t, std::allocator<size_t>>::back() const```</span>.
    pub unsafe fn back(&self) -> ::cpp_core::Ref<usize> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_back1(
            self as *const crate::VectorOfUsize,
        );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<size_t, std::allocator<size_t>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_capacity(
            self as *const crate::VectorOfUsize,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<size_t, std::allocator<size_t>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_clear(
            self as *mut crate::VectorOfUsize,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<size_t, std::allocator<size_t>>& std::vector<size_t, std::allocator<size_t>>::operator=(const std::vector<size_t, std::allocator<size_t>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUsize>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfUsize> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_operator_(
                self as *mut crate::VectorOfUsize,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUsize>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t* std::vector<size_t, std::allocator<size_t>>::data()```</span>.
    pub unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<usize> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_data(
            self as *mut crate::VectorOfUsize,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```const size_t* std::vector<size_t, std::allocator<size_t>>::data() const```</span>.
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<usize> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_data1(
            self as *const crate::VectorOfUsize,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<size_t, std::allocator<size_t>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_empty(
            self as *const crate::VectorOfUsize,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t& std::vector<size_t, std::allocator<size_t>>::front()```</span>.
    pub unsafe fn front_mut(&mut self) -> ::cpp_core::MutRef<usize> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_front(
            self as *mut crate::VectorOfUsize,
        );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const size_t& std::vector<size_t, std::allocator<size_t>>::front() const```</span>.
    pub unsafe fn front(&self) -> ::cpp_core::Ref<usize> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_front1(
                self as *const crate::VectorOfUsize,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t& std::vector<size_t, std::allocator<size_t>>::operator[](size_t __n)```</span>.
    pub unsafe fn index_mut(&mut self, n: usize) -> ::cpp_core::MutRef<usize> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_operator__(
                self as *mut crate::VectorOfUsize,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```const size_t& std::vector<size_t, std::allocator<size_t>>::operator[](size_t __n) const```</span>.
    pub unsafe fn index(&self, n: usize) -> ::cpp_core::Ref<usize> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_operator__1(
                self as *const crate::VectorOfUsize,
                n,
            );
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<size_t, std::allocator<size_t>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_max_size(
            self as *const crate::VectorOfUsize,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<size_t, std::allocator<size_t>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfUsize> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<size_t, std::allocator<size_t>>::vector(const std::allocator<size_t>& __a)```</span>.
    pub unsafe fn from_allocator_of_usize(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUsize>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUsize> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUsize>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<size_t, std::allocator<size_t>>::vector(size_t __n, const std::allocator<size_t>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_usize(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUsize>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUsize> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUsize>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<size_t, std::allocator<size_t>>::vector(size_t __n, const size_t& __value, const std::allocator<size_t>& __a = …)```</span>.
    pub unsafe fn from_usize_usize_allocator_of_usize(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<usize>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUsize>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUsize> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_vector4(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<usize>>::cast_into(value).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUsize>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<size_t, std::allocator<size_t>>::vector(const std::vector<size_t, std::allocator<size_t>>& __x, const std::allocator<size_t>& __a)```</span>.
    pub unsafe fn from_vector_of_usize_allocator_of_usize(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUsize>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUsize>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUsize> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUsize>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUsize>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<size_t, std::allocator<size_t>>::vector(const size_t* first, const size_t* last, std::allocator<size_t> alloc = …)```</span>.
    pub unsafe fn from_2_usize_allocator_of_usize(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<usize>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<usize>>,
        alloc: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfUsize>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUsize> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_vector8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<usize>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<usize>>::cast_into(last).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfUsize>>::cast_into(alloc)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<size_t, std::allocator<size_t>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfUsize> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<size_t, std::allocator<size_t>>::vector(size_t __n, const size_t& __value)```</span>.
    pub unsafe fn from_usize_usize(
        n: usize,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<usize>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUsize> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_vector10(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<usize>>::cast_into(value).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<size_t, std::allocator<size_t>>::vector(const size_t* first, const size_t* last)```</span>.
    pub unsafe fn from_2_usize(
        first: impl ::cpp_core::CastInto<::cpp_core::Ptr<usize>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ptr<usize>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUsize> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_vector11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<usize>>::cast_into(first).as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<usize>>::cast_into(last).as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<size_t, std::allocator<size_t>>::vector(const std::vector<size_t, std::allocator<size_t>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfUsize>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfUsize> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfUsize>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<size_t, std::allocator<size_t>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_pop_back(
            self as *mut crate::VectorOfUsize,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<size_t, std::allocator<size_t>>::push_back(const size_t& __x)```</span>.
    pub unsafe fn push_back(&mut self, x: impl ::cpp_core::CastInto<::cpp_core::Ref<usize>>) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_push_back(
            self as *mut crate::VectorOfUsize,
            ::cpp_core::CastInto::<::cpp_core::Ref<usize>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<size_t, std::allocator<size_t>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_reserve(
            self as *mut crate::VectorOfUsize,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<size_t, std::allocator<size_t>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize_1a(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_resize(
            self as *mut crate::VectorOfUsize,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<size_t, std::allocator<size_t>>::resize(size_t __new_size, const size_t& __x)```</span>.
    pub unsafe fn resize_2a(
        &mut self,
        new_size: usize,
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<usize>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_resize1(
            self as *mut crate::VectorOfUsize,
            new_size,
            ::cpp_core::CastInto::<::cpp_core::Ref<usize>>::cast_into(x).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<size_t, std::allocator<size_t>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_shrink_to_fit(
            self as *mut crate::VectorOfUsize,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<size_t, std::allocator<size_t>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_size(
            self as *const crate::VectorOfUsize,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<size_t, std::allocator<size_t>>::swap(std::vector<size_t, std::allocator<size_t>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUsize>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_swap(
            self as *mut crate::VectorOfUsize,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUsize>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

/// C++ class: <span style='color: green;'>```std::vector<void*, std::allocator<void*>>```</span>.
#[repr(C)]
pub struct VectorOfVoid {
    _unused: u8,
}
impl VectorOfVoid {
    /// Calls C++ function: <span style='color: green;'>```void*& std::vector<void*, std::allocator<void*>>::at(size_t __n)```</span>.
    pub unsafe fn at(&mut self, n: usize) -> ::cpp_core::MutRef<*mut ::std::ffi::c_void> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_at(
                self as *mut crate::VectorOfVoid,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```void*& std::vector<void*, std::allocator<void*>>::back()```</span>.
    pub unsafe fn back(&mut self) -> ::cpp_core::MutRef<*mut ::std::ffi::c_void> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_back(
                self as *mut crate::VectorOfVoid,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<void*, std::allocator<void*>>::capacity() const```</span>.
    pub unsafe fn capacity(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_capacity(
            self as *const crate::VectorOfVoid,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<void*, std::allocator<void*>>::clear()```</span>.
    pub unsafe fn clear(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_clear(
            self as *mut crate::VectorOfVoid,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```std::vector<void*, std::allocator<void*>>& std::vector<void*, std::allocator<void*>>::operator=(const std::vector<void*, std::allocator<void*>>& other)```</span>.
    pub unsafe fn copy_from(
        &mut self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfVoid>>,
    ) -> ::cpp_core::MutRef<crate::VectorOfVoid> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_operator_(
                self as *mut crate::VectorOfVoid,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfVoid>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```void** std::vector<void*, std::allocator<void*>>::data()```</span>.
    pub unsafe fn data(&mut self) -> ::cpp_core::MutPtr<*mut ::std::ffi::c_void> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_data(
                self as *mut crate::VectorOfVoid,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```bool std::vector<void*, std::allocator<void*>>::empty() const```</span>.
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_empty(
            self as *const crate::VectorOfVoid,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void*& std::vector<void*, std::allocator<void*>>::front()```</span>.
    pub unsafe fn front(&mut self) -> ::cpp_core::MutRef<*mut ::std::ffi::c_void> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_front(
                self as *mut crate::VectorOfVoid,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```void*& std::vector<void*, std::allocator<void*>>::operator[](size_t __n)```</span>.
    pub unsafe fn index(&mut self, n: usize) -> ::cpp_core::MutRef<*mut ::std::ffi::c_void> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_operator__(
                self as *mut crate::VectorOfVoid,
                n,
            );
        ::cpp_core::MutRef::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<void*, std::allocator<void*>>::max_size() const```</span>.
    pub unsafe fn max_size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_max_size(
            self as *const crate::VectorOfVoid,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<void*, std::allocator<void*>>::vector()```</span>.
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::VectorOfVoid> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_vector();
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<void*, std::allocator<void*>>::vector(const std::allocator<void*>& __a)```</span>.
    pub unsafe fn from_allocator_of_void(
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfVoid>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfVoid> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_vector2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfVoid>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<void*, std::allocator<void*>>::vector(size_t __n, const std::allocator<void*>& __a = …)```</span>.
    pub unsafe fn from_usize_allocator_of_void(
        n: usize,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfVoid>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfVoid> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_vector3(
                n,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfVoid>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<void*, std::allocator<void*>>::vector(const std::vector<void*, std::allocator<void*>>& __x, const std::allocator<void*>& __a)```</span>.
    pub unsafe fn from_vector_of_void_allocator_of_void(
        x: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfVoid>>,
        a: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::AllocatorOfVoid>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfVoid> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_vector6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfVoid>>::cast_into(x)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::AllocatorOfVoid>>::cast_into(a)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<void*, std::allocator<void*>>::vector(size_t __n)```</span>.
    pub unsafe fn from_usize(n: usize) -> ::cpp_core::CppBox<crate::VectorOfVoid> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_vector9(n);
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void std::vector<void*, std::allocator<void*>>::vector(const std::vector<void*, std::allocator<void*>>& other)```</span>.
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::VectorOfVoid>>,
    ) -> ::cpp_core::CppBox<crate::VectorOfVoid> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_vector1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::VectorOfVoid>>::cast_into(other)
                    .as_raw_ptr(),
            );
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<void*, std::allocator<void*>>::pop_back()```</span>.
    pub unsafe fn pop_back(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_pop_back(
            self as *mut crate::VectorOfVoid,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<void*, std::allocator<void*>>::reserve(size_t __n)```</span>.
    pub unsafe fn reserve(&mut self, n: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_reserve(
            self as *mut crate::VectorOfVoid,
            n,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<void*, std::allocator<void*>>::resize(size_t __new_size)```</span>.
    pub unsafe fn resize(&mut self, new_size: usize) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_resize(
            self as *mut crate::VectorOfVoid,
            new_size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<void*, std::allocator<void*>>::shrink_to_fit()```</span>.
    pub unsafe fn shrink_to_fit(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_shrink_to_fit(
            self as *mut crate::VectorOfVoid,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<void*, std::allocator<void*>>::size() const```</span>.
    pub unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_size(
            self as *const crate::VectorOfVoid,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void std::vector<void*, std::allocator<void*>>::swap(std::vector<void*, std::allocator<void*>>& __x)```</span>.
    pub unsafe fn swap(
        &mut self,
        x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfVoid>>,
    ) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_swap(
            self as *mut crate::VectorOfVoid,
            ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfVoid>>::cast_into(x)
                .as_mut_raw_ptr(),
        )
    }
}

impl ::cpp_core::CppDeletable for crate::PiecewiseConstructT {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::piecewise_construct_t::~piecewise_construct_t()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_piecewise_construct_t_dpiecewise_construct_t(
            self as *mut crate::PiecewiseConstructT,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::InputIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::input_iterator_tag::~input_iterator_tag()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_input_iterator_tag_dinput_iterator_tag(
            self as *mut crate::InputIteratorTag,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::OutputIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::output_iterator_tag::~output_iterator_tag()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_output_iterator_tag_doutput_iterator_tag(
            self as *mut crate::OutputIteratorTag,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::ForwardIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::forward_iterator_tag::~forward_iterator_tag()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_forward_iterator_tag_dforward_iterator_tag(
            self as *mut crate::ForwardIteratorTag,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::BidirectionalIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::bidirectional_iterator_tag::~bidirectional_iterator_tag()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_bidirectional_iterator_tag_dbidirectional_iterator_tag(
            self as *mut crate::BidirectionalIteratorTag,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::RandomAccessIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::random_access_iterator_tag::~random_access_iterator_tag()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_random_access_iterator_tag_drandom_access_iterator_tag(
            self as *mut crate::RandomAccessIteratorTag,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfBool {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<bool, std::allocator<bool>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_dvector(
            self as *mut crate::VectorOfBool,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfChar {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<char, std::allocator<char>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_dvector(
            self as *mut crate::VectorOfChar,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfSchar {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<signed char, std::allocator<signed char>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_dvector(
            self as *mut crate::VectorOfSchar,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfUchar {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<unsigned char, std::allocator<unsigned char>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_dvector(
            self as *mut crate::VectorOfUchar,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfWcharT {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<wchar_t, std::allocator<wchar_t>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_dvector(
            self as *mut crate::VectorOfWcharT,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfChar16T {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<char16_t, std::allocator<char16_t>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_dvector(
            self as *mut crate::VectorOfChar16T,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfChar32T {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<char32_t, std::allocator<char32_t>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_dvector(
            self as *mut crate::VectorOfChar32T,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfShort {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<short, std::allocator<short>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_dvector(
            self as *mut crate::VectorOfShort,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfUshort {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<unsigned short, std::allocator<unsigned short>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_dvector(
            self as *mut crate::VectorOfUshort,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfInt {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<int, std::allocator<int>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_dvector(
            self as *mut crate::VectorOfInt,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfUint {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<unsigned int, std::allocator<unsigned int>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_dvector(
            self as *mut crate::VectorOfUint,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfLong {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<long, std::allocator<long>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_dvector(
            self as *mut crate::VectorOfLong,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfUlong {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<unsigned long, std::allocator<unsigned long>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_dvector(
            self as *mut crate::VectorOfUlong,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfLonglong {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<long long, std::allocator<long long>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_dvector(
            self as *mut crate::VectorOfLonglong,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfUlonglong {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<unsigned long long, std::allocator<unsigned long long>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_dvector(self as *mut crate::VectorOfUlonglong)
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfFloat {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<float, std::allocator<float>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_dvector(
            self as *mut crate::VectorOfFloat,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfDouble {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<double, std::allocator<double>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_dvector(
            self as *mut crate::VectorOfDouble,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfI8 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<int8_t, std::allocator<int8_t>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_dvector(
            self as *mut crate::VectorOfI8,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfU8 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<uint8_t, std::allocator<uint8_t>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_dvector(
            self as *mut crate::VectorOfU8,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfI16 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<int16_t, std::allocator<int16_t>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_dvector(
            self as *mut crate::VectorOfI16,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfU16 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<uint16_t, std::allocator<uint16_t>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_dvector(
            self as *mut crate::VectorOfU16,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfI32 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<int32_t, std::allocator<int32_t>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_dvector(
            self as *mut crate::VectorOfI32,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfU32 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<uint32_t, std::allocator<uint32_t>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_dvector(
            self as *mut crate::VectorOfU32,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfI64 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<int64_t, std::allocator<int64_t>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_dvector(
            self as *mut crate::VectorOfI64,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfU64 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<uint64_t, std::allocator<uint64_t>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_dvector(
            self as *mut crate::VectorOfU64,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfUsize {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<size_t, std::allocator<size_t>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_dvector(
            self as *mut crate::VectorOfUsize,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::VectorOfVoid {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::vector<void*, std::allocator<void*>>::~vector()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_dvector(
            self as *mut crate::VectorOfVoid,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfChar {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<char>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_char_dallocator(
            self as *mut crate::AllocatorOfChar,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfWcharT {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<wchar_t>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_wchar_t_dallocator(
            self as *mut crate::AllocatorOfWcharT,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfChar16T {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<char16_t>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_char16_t_dallocator(
            self as *mut crate::AllocatorOfChar16T,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfChar32T {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<char32_t>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_char32_t_dallocator(
            self as *mut crate::AllocatorOfChar32T,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfBool {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<bool>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_bool_dallocator(
            self as *mut crate::AllocatorOfBool,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfSchar {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<signed char>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_signed_char_dallocator(
            self as *mut crate::AllocatorOfSchar,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfUchar {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<unsigned char>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_char_dallocator(
            self as *mut crate::AllocatorOfUchar,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfShort {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<short>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_short_dallocator(
            self as *mut crate::AllocatorOfShort,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfUshort {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<unsigned short>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_short_dallocator(
            self as *mut crate::AllocatorOfUshort,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfInt {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<int>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_int_dallocator(
            self as *mut crate::AllocatorOfInt,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfUint {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<unsigned int>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_int_dallocator(
            self as *mut crate::AllocatorOfUint,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfLong {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<long>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_long_dallocator(
            self as *mut crate::AllocatorOfLong,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfUlong {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<unsigned long>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_long_dallocator(
            self as *mut crate::AllocatorOfUlong,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfLonglong {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<long long>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_long_long_dallocator(
            self as *mut crate::AllocatorOfLonglong,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfUlonglong {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<unsigned long long>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_unsigned_long_long_dallocator(
            self as *mut crate::AllocatorOfUlonglong,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfFloat {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<float>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_float_dallocator(
            self as *mut crate::AllocatorOfFloat,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfDouble {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<double>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_double_dallocator(
            self as *mut crate::AllocatorOfDouble,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfI8 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<int8_t>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_int8_t_dallocator(
            self as *mut crate::AllocatorOfI8,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfU8 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<uint8_t>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint8_t_dallocator(
            self as *mut crate::AllocatorOfU8,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfI16 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<int16_t>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_int16_t_dallocator(
            self as *mut crate::AllocatorOfI16,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfU16 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<uint16_t>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint16_t_dallocator(
            self as *mut crate::AllocatorOfU16,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfI32 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<int32_t>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_int32_t_dallocator(
            self as *mut crate::AllocatorOfI32,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfU32 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<uint32_t>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint32_t_dallocator(
            self as *mut crate::AllocatorOfU32,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfI64 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<int64_t>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_int64_t_dallocator(
            self as *mut crate::AllocatorOfI64,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfU64 {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<uint64_t>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_uint64_t_dallocator(
            self as *mut crate::AllocatorOfU64,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfUsize {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<size_t>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_size_t_dallocator(
            self as *mut crate::AllocatorOfUsize,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::AllocatorOfVoid {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::allocator<void*>::~allocator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_allocator_void_ptr_dallocator(
            self as *mut crate::AllocatorOfVoid,
        )
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfChar>> for crate::AllocatorOfChar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<char>& arg1, const std::allocator<char>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfChar>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__1(
                self as *const crate::AllocatorOfChar,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfWcharT>> for crate::AllocatorOfWcharT {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<wchar_t>& arg1, const std::allocator<wchar_t>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfWcharT>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__2(
                self as *const crate::AllocatorOfWcharT,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfChar16T>>
    for crate::AllocatorOfChar16T
{
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<char16_t>& arg1, const std::allocator<char16_t>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfChar16T>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__3(
                self as *const crate::AllocatorOfChar16T,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfChar32T>>
    for crate::AllocatorOfChar32T
{
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<char32_t>& arg1, const std::allocator<char32_t>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfChar32T>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__4(
                self as *const crate::AllocatorOfChar32T,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfBool>> for crate::AllocatorOfBool {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<bool>& arg1, const std::allocator<bool>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfBool>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__5(
                self as *const crate::AllocatorOfBool,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfSchar>> for crate::AllocatorOfSchar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<signed char>& arg1, const std::allocator<signed char>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfSchar>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__6(
                self as *const crate::AllocatorOfSchar,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfUchar>> for crate::AllocatorOfUchar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<unsigned char>& arg1, const std::allocator<unsigned char>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfUchar>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__7(
                self as *const crate::AllocatorOfUchar,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfShort>> for crate::AllocatorOfShort {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<short>& arg1, const std::allocator<short>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfShort>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__8(
                self as *const crate::AllocatorOfShort,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfUshort>> for crate::AllocatorOfUshort {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<unsigned short>& arg1, const std::allocator<unsigned short>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfUshort>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__9(
                self as *const crate::AllocatorOfUshort,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfInt>> for crate::AllocatorOfInt {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<int>& arg1, const std::allocator<int>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfInt>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__10(
                self as *const crate::AllocatorOfInt,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfUint>> for crate::AllocatorOfUint {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<unsigned int>& arg1, const std::allocator<unsigned int>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfUint>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__11(
                self as *const crate::AllocatorOfUint,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfLong>> for crate::AllocatorOfLong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<long>& arg1, const std::allocator<long>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfLong>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__12(
                self as *const crate::AllocatorOfLong,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfUlong>> for crate::AllocatorOfUlong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<unsigned long>& arg1, const std::allocator<unsigned long>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfUlong>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__13(
                self as *const crate::AllocatorOfUlong,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfLonglong>>
    for crate::AllocatorOfLonglong
{
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<long long>& arg1, const std::allocator<long long>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfLonglong>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__14(
                self as *const crate::AllocatorOfLonglong,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfUlonglong>>
    for crate::AllocatorOfUlonglong
{
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<unsigned long long>& arg1, const std::allocator<unsigned long long>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfUlonglong>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__15(
                self as *const crate::AllocatorOfUlonglong,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfFloat>> for crate::AllocatorOfFloat {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<float>& arg1, const std::allocator<float>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfFloat>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__16(
                self as *const crate::AllocatorOfFloat,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfDouble>> for crate::AllocatorOfDouble {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<double>& arg1, const std::allocator<double>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfDouble>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__17(
                self as *const crate::AllocatorOfDouble,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfI8>> for crate::AllocatorOfI8 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<int8_t>& arg1, const std::allocator<int8_t>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfI8>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__18(
                self as *const crate::AllocatorOfI8,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfU8>> for crate::AllocatorOfU8 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<uint8_t>& arg1, const std::allocator<uint8_t>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfU8>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__19(
                self as *const crate::AllocatorOfU8,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfI16>> for crate::AllocatorOfI16 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<int16_t>& arg1, const std::allocator<int16_t>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfI16>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__20(
                self as *const crate::AllocatorOfI16,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfU16>> for crate::AllocatorOfU16 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<uint16_t>& arg1, const std::allocator<uint16_t>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfU16>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__21(
                self as *const crate::AllocatorOfU16,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfI32>> for crate::AllocatorOfI32 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<int32_t>& arg1, const std::allocator<int32_t>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfI32>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__22(
                self as *const crate::AllocatorOfI32,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfU32>> for crate::AllocatorOfU32 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<uint32_t>& arg1, const std::allocator<uint32_t>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfU32>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__23(
                self as *const crate::AllocatorOfU32,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfI64>> for crate::AllocatorOfI64 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<int64_t>& arg1, const std::allocator<int64_t>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfI64>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__24(
                self as *const crate::AllocatorOfI64,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfU64>> for crate::AllocatorOfU64 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<uint64_t>& arg1, const std::allocator<uint64_t>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfU64>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__25(
                self as *const crate::AllocatorOfU64,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfUsize>> for crate::AllocatorOfUsize {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<size_t>& arg1, const std::allocator<size_t>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfUsize>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__26(
                self as *const crate::AllocatorOfUsize,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::AllocatorOfVoid>> for crate::AllocatorOfVoid {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::allocator<void*>& arg1, const std::allocator<void*>& arg2)```</span>.
    fn eq(&self, arg2: &::cpp_core::Ref<crate::AllocatorOfVoid>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__27(
                self as *const crate::AllocatorOfVoid,
                arg2.as_raw_ptr(),
            )
        }
    }
}

impl ::cpp_core::CppDeletable for crate::String {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::basic_string<char, std::char_traits<char>, std::allocator<char>>::~basic_string()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_dbasic_string(self as *mut crate::String)
    }
}

impl ::cpp_core::CppDeletable for crate::WString {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::~basic_string()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_dbasic_string(self as *mut crate::WString)
    }
}

impl ::cpp_core::CppDeletable for crate::U16String {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::~basic_string()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_dbasic_string(self as *mut crate::U16String)
    }
}

impl ::cpp_core::CppDeletable for crate::U32String {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::~basic_string()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_dbasic_string(self as *mut crate::U32String)
    }
}

impl ::cpp_core::vector_ops::Size for crate::String {
    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char, std::char_traits<char>, std::allocator<char>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_size(self as *const crate::String)
    }
}

impl ::cpp_core::vector_ops::Size for crate::WString {
    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_size(self as *const crate::WString)
    }
}

impl ::cpp_core::vector_ops::Size for crate::U16String {
    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_size(self as *const crate::U16String)
    }
}

impl ::cpp_core::vector_ops::Size for crate::U32String {
    /// Calls C++ function: <span style='color: green;'>```size_t std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_size(self as *const crate::U32String)
    }
}

impl ::std::ops::AddAssign<::cpp_core::Ref<crate::String>> for crate::String {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::operator+=(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str)```</span>.
    fn add_assign(&mut self, str: ::cpp_core::Ref<crate::String>) {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_operator__2(self as *mut crate::String, str.as_raw_ptr())
        };
        let _ = ffi_result;
    }
}

impl ::std::ops::AddAssign<::cpp_core::Ref<crate::WString>> for crate::WString {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::operator+=(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str)```</span>.
    fn add_assign(&mut self, str: ::cpp_core::Ref<crate::WString>) {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_operator__2(self as *mut crate::WString, str.as_raw_ptr())
        };
        let _ = ffi_result;
    }
}

impl ::std::ops::AddAssign<::cpp_core::Ref<crate::U16String>> for crate::U16String {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::operator+=(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __str)```</span>.
    fn add_assign(&mut self, str: ::cpp_core::Ref<crate::U16String>) {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_operator__2(self as *mut crate::U16String, str.as_raw_ptr())
        };
        let _ = ffi_result;
    }
}

impl ::std::ops::AddAssign<::cpp_core::Ref<crate::U32String>> for crate::U32String {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::operator+=(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __str)```</span>.
    fn add_assign(&mut self, str: ::cpp_core::Ref<crate::U32String>) {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_operator__2(self as *mut crate::U32String, str.as_raw_ptr())
        };
        let _ = ffi_result;
    }
}

impl ::std::ops::AddAssign<::cpp_core::Ptr<::std::os::raw::c_char>> for crate::String {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::operator+=(const char* __s)```</span>.
    fn add_assign(&mut self, s: ::cpp_core::Ptr<::std::os::raw::c_char>) {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_operator__3(self as *mut crate::String, s.as_raw_ptr())
        };
        let _ = ffi_result;
    }
}

impl ::std::ops::AddAssign<::cpp_core::Ptr<::cpp_core::wchar_t>> for crate::WString {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::operator+=(const wchar_t* __s)```</span>.
    fn add_assign(&mut self, s: ::cpp_core::Ptr<::cpp_core::wchar_t>) {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_operator__3(self as *mut crate::WString, s.as_raw_ptr())
        };
        let _ = ffi_result;
    }
}

impl ::std::ops::AddAssign<::cpp_core::Ptr<::cpp_core::char16_t>> for crate::U16String {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::operator+=(const char16_t* __s)```</span>.
    fn add_assign(&mut self, s: ::cpp_core::Ptr<::cpp_core::char16_t>) {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_operator__3(self as *mut crate::U16String, s.as_raw_ptr())
        };
        let _ = ffi_result;
    }
}

impl ::std::ops::AddAssign<::cpp_core::Ptr<::cpp_core::char32_t>> for crate::U32String {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::operator+=(const char32_t* __s)```</span>.
    fn add_assign(&mut self, s: ::cpp_core::Ptr<::cpp_core::char32_t>) {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_operator__3(self as *mut crate::U32String, s.as_raw_ptr())
        };
        let _ = ffi_result;
    }
}

impl ::std::ops::AddAssign<::std::os::raw::c_char> for crate::String {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::operator+=(char __c)```</span>.
    fn add_assign(&mut self, c: ::std::os::raw::c_char) {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_operator__4(self as *mut crate::String, c)
        };
        let _ = ffi_result;
    }
}

impl ::std::ops::AddAssign<::cpp_core::wchar_t> for crate::WString {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::operator+=(wchar_t __c)```</span>.
    fn add_assign(&mut self, c: ::cpp_core::wchar_t) {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_operator__4(self as *mut crate::WString, c)
        };
        let _ = ffi_result;
    }
}

impl ::std::ops::AddAssign<::cpp_core::char16_t> for crate::U16String {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::operator+=(char16_t __c)```</span>.
    fn add_assign(&mut self, c: ::cpp_core::char16_t) {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_operator__4(self as *mut crate::U16String, c)
        };
        let _ = ffi_result;
    }
}

impl ::std::ops::AddAssign<::cpp_core::char32_t> for crate::U32String {
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::operator+=(char32_t __c)```</span>.
    fn add_assign(&mut self, c: ::cpp_core::char32_t) {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_operator__4(self as *mut crate::U32String, c)
        };
        let _ = ffi_result;
    }
}

impl ::cpp_core::vector_ops::Data for crate::String {
    type Output = ::cpp_core::Ptr<::std::os::raw::c_char>;
    /// Calls C++ function: <span style='color: green;'>```const char* std::basic_string<char, std::char_traits<char>, std::allocator<char>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char_std_char_traits_char_std_allocator_char_data(self as *const crate::String);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::WString {
    type Output = ::cpp_core::Ptr<::cpp_core::wchar_t>;
    /// Calls C++ function: <span style='color: green;'>```const wchar_t* std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::cpp_core::wchar_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_wchar_t_std_char_traits_wchar_t_std_allocator_wchar_t_data(self as *const crate::WString);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::U16String {
    type Output = ::cpp_core::Ptr<::cpp_core::char16_t>;
    /// Calls C++ function: <span style='color: green;'>```const char16_t* std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::cpp_core::char16_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char16_t_std_char_traits_char16_t_std_allocator_char16_t_data(self as *const crate::U16String);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::U32String {
    type Output = ::cpp_core::Ptr<::cpp_core::char32_t>;
    /// Calls C++ function: <span style='color: green;'>```const char32_t* std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::cpp_core::char32_t> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_basic_string_char32_t_std_char_traits_char32_t_std_allocator_char32_t_data(self as *const crate::U32String);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Add<::cpp_core::Ref<crate::String>> for &crate::String {
    type Output = ::cpp_core::CppBox<crate::String>;
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::operator+(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __lhs, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __rhs)```</span>.
    fn add(self, rhs: ::cpp_core::Ref<crate::String>) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator_(
                self as *const crate::String,
                rhs.as_raw_ptr(),
            )
        };
        unsafe {
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }
}

impl ::std::ops::Add<::cpp_core::Ref<crate::WString>> for &crate::WString {
    type Output = ::cpp_core::CppBox<crate::WString>;
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::operator+(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __lhs, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __rhs)```</span>.
    fn add(self, rhs: ::cpp_core::Ref<crate::WString>) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator_1(
                self as *const crate::WString,
                rhs.as_raw_ptr(),
            )
        };
        unsafe {
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }
}

impl ::std::ops::Add<::cpp_core::Ref<crate::U16String>> for &crate::U16String {
    type Output = ::cpp_core::CppBox<crate::U16String>;
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>> std::operator+(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __lhs, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __rhs)```</span>.
    fn add(self, rhs: ::cpp_core::Ref<crate::U16String>) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator_2(
                self as *const crate::U16String,
                rhs.as_raw_ptr(),
            )
        };
        unsafe {
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }
}

impl ::std::ops::Add<::cpp_core::Ref<crate::U32String>> for &crate::U32String {
    type Output = ::cpp_core::CppBox<crate::U32String>;
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>> std::operator+(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __lhs, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __rhs)```</span>.
    fn add(self, rhs: ::cpp_core::Ref<crate::U32String>) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator_3(
                self as *const crate::U32String,
                rhs.as_raw_ptr(),
            )
        };
        unsafe {
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }
}

impl ::std::ops::Add<::cpp_core::Ptr<::std::os::raw::c_char>> for &crate::String {
    type Output = ::cpp_core::CppBox<crate::String>;
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::operator+(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __lhs, const char* __rhs)```</span>.
    fn add(
        self,
        rhs: ::cpp_core::Ptr<::std::os::raw::c_char>,
    ) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator_12(
                self as *const crate::String,
                rhs.as_raw_ptr(),
            )
        };
        unsafe {
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }
}

impl ::std::ops::Add<::cpp_core::Ptr<::cpp_core::wchar_t>> for &crate::WString {
    type Output = ::cpp_core::CppBox<crate::WString>;
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::operator+(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __lhs, const wchar_t* __rhs)```</span>.
    fn add(self, rhs: ::cpp_core::Ptr<::cpp_core::wchar_t>) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator_13(
                self as *const crate::WString,
                rhs.as_raw_ptr(),
            )
        };
        unsafe {
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }
}

impl ::std::ops::Add<::cpp_core::Ptr<::cpp_core::char16_t>> for &crate::U16String {
    type Output = ::cpp_core::CppBox<crate::U16String>;
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>> std::operator+(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __lhs, const char16_t* __rhs)```</span>.
    fn add(
        self,
        rhs: ::cpp_core::Ptr<::cpp_core::char16_t>,
    ) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator_14(
                self as *const crate::U16String,
                rhs.as_raw_ptr(),
            )
        };
        unsafe {
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }
}

impl ::std::ops::Add<::cpp_core::Ptr<::cpp_core::char32_t>> for &crate::U32String {
    type Output = ::cpp_core::CppBox<crate::U32String>;
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>> std::operator+(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __lhs, const char32_t* __rhs)```</span>.
    fn add(
        self,
        rhs: ::cpp_core::Ptr<::cpp_core::char32_t>,
    ) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator_15(
                self as *const crate::U32String,
                rhs.as_raw_ptr(),
            )
        };
        unsafe {
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }
}

impl ::std::ops::Add<::std::os::raw::c_char> for &crate::String {
    type Output = ::cpp_core::CppBox<crate::String>;
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::operator+(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __lhs, char __rhs)```</span>.
    fn add(self, rhs: ::std::os::raw::c_char) -> ::cpp_core::CppBox<crate::String> {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator_16(self as *const crate::String, rhs)
        };
        unsafe {
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }
}

impl ::std::ops::Add<::cpp_core::wchar_t> for &crate::WString {
    type Output = ::cpp_core::CppBox<crate::WString>;
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::operator+(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __lhs, wchar_t __rhs)```</span>.
    fn add(self, rhs: ::cpp_core::wchar_t) -> ::cpp_core::CppBox<crate::WString> {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator_17(self as *const crate::WString, rhs)
        };
        unsafe {
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }
}

impl ::std::ops::Add<::cpp_core::char16_t> for &crate::U16String {
    type Output = ::cpp_core::CppBox<crate::U16String>;
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>> std::operator+(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __lhs, char16_t __rhs)```</span>.
    fn add(self, rhs: ::cpp_core::char16_t) -> ::cpp_core::CppBox<crate::U16String> {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator_18(self as *const crate::U16String, rhs)
        };
        unsafe {
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }
}

impl ::std::ops::Add<::cpp_core::char32_t> for &crate::U32String {
    type Output = ::cpp_core::CppBox<crate::U32String>;
    /// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>> std::operator+(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __lhs, char32_t __rhs)```</span>.
    fn add(self, rhs: ::cpp_core::char32_t) -> ::cpp_core::CppBox<crate::U32String> {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator_19(self as *const crate::U32String, rhs)
        };
        unsafe {
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::String>> for crate::String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __lhs, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __rhs)```</span>.
    fn eq(&self, rhs: &::cpp_core::Ref<crate::String>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__55(
                self as *const crate::String,
                rhs.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::WString>> for crate::WString {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __lhs, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __rhs)```</span>.
    fn eq(&self, rhs: &::cpp_core::Ref<crate::WString>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__56(
                self as *const crate::WString,
                rhs.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::U16String>> for crate::U16String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __lhs, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __rhs)```</span>.
    fn eq(&self, rhs: &::cpp_core::Ref<crate::U16String>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__57(
                self as *const crate::U16String,
                rhs.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::U32String>> for crate::U32String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __lhs, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __rhs)```</span>.
    fn eq(&self, rhs: &::cpp_core::Ref<crate::U32String>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__58(
                self as *const crate::U32String,
                rhs.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ptr<::std::os::raw::c_char>> for crate::String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __lhs, const char* __rhs)```</span>.
    fn eq(&self, rhs: &::cpp_core::Ptr<::std::os::raw::c_char>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__63(
                self as *const crate::String,
                rhs.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ptr<::cpp_core::wchar_t>> for crate::WString {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __lhs, const wchar_t* __rhs)```</span>.
    fn eq(&self, rhs: &::cpp_core::Ptr<::cpp_core::wchar_t>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__64(
                self as *const crate::WString,
                rhs.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ptr<::cpp_core::char16_t>> for crate::U16String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __lhs, const char16_t* __rhs)```</span>.
    fn eq(&self, rhs: &::cpp_core::Ptr<::cpp_core::char16_t>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__65(
                self as *const crate::U16String,
                rhs.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ptr<::cpp_core::char32_t>> for crate::U32String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __lhs, const char32_t* __rhs)```</span>.
    fn eq(&self, rhs: &::cpp_core::Ptr<::cpp_core::char32_t>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__66(
                self as *const crate::U32String,
                rhs.as_raw_ptr(),
            )
        }
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::String>> for crate::String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __lhs, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __rhs)```</span>.
    unsafe fn lt(&self, rhs: &::cpp_core::Ref<crate::String>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_48(
            self as *const crate::String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::WString>> for crate::WString {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __lhs, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __rhs)```</span>.
    unsafe fn lt(&self, rhs: &::cpp_core::Ref<crate::WString>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_49(
            self as *const crate::WString,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::U16String>> for crate::U16String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __lhs, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __rhs)```</span>.
    unsafe fn lt(&self, rhs: &::cpp_core::Ref<crate::U16String>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_50(
            self as *const crate::U16String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::U32String>> for crate::U32String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __lhs, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __rhs)```</span>.
    unsafe fn lt(&self, rhs: &::cpp_core::Ref<crate::U32String>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_51(
            self as *const crate::U32String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ptr<::std::os::raw::c_char>> for crate::String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __lhs, const char* __rhs)```</span>.
    unsafe fn lt(&self, rhs: &::cpp_core::Ptr<::std::os::raw::c_char>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_52(
            self as *const crate::String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ptr<::cpp_core::wchar_t>> for crate::WString {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __lhs, const wchar_t* __rhs)```</span>.
    unsafe fn lt(&self, rhs: &::cpp_core::Ptr<::cpp_core::wchar_t>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_53(
            self as *const crate::WString,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ptr<::cpp_core::char16_t>> for crate::U16String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __lhs, const char16_t* __rhs)```</span>.
    unsafe fn lt(&self, rhs: &::cpp_core::Ptr<::cpp_core::char16_t>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_54(
            self as *const crate::U16String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ptr<::cpp_core::char32_t>> for crate::U32String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __lhs, const char32_t* __rhs)```</span>.
    unsafe fn lt(&self, rhs: &::cpp_core::Ptr<::cpp_core::char32_t>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_55(
            self as *const crate::U32String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::String>> for crate::String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __lhs, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __rhs)```</span>.
    unsafe fn gt(&self, rhs: &::cpp_core::Ref<crate::String>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_60(
            self as *const crate::String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::WString>> for crate::WString {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __lhs, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __rhs)```</span>.
    unsafe fn gt(&self, rhs: &::cpp_core::Ref<crate::WString>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_61(
            self as *const crate::WString,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::U16String>> for crate::U16String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __lhs, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __rhs)```</span>.
    unsafe fn gt(&self, rhs: &::cpp_core::Ref<crate::U16String>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_62(
            self as *const crate::U16String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::U32String>> for crate::U32String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __lhs, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __rhs)```</span>.
    unsafe fn gt(&self, rhs: &::cpp_core::Ref<crate::U32String>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_63(
            self as *const crate::U32String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ptr<::std::os::raw::c_char>> for crate::String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __lhs, const char* __rhs)```</span>.
    unsafe fn gt(&self, rhs: &::cpp_core::Ptr<::std::os::raw::c_char>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_64(
            self as *const crate::String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ptr<::cpp_core::wchar_t>> for crate::WString {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __lhs, const wchar_t* __rhs)```</span>.
    unsafe fn gt(&self, rhs: &::cpp_core::Ptr<::cpp_core::wchar_t>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_65(
            self as *const crate::WString,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ptr<::cpp_core::char16_t>> for crate::U16String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __lhs, const char16_t* __rhs)```</span>.
    unsafe fn gt(&self, rhs: &::cpp_core::Ptr<::cpp_core::char16_t>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_66(
            self as *const crate::U16String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ptr<::cpp_core::char32_t>> for crate::U32String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __lhs, const char32_t* __rhs)```</span>.
    unsafe fn gt(&self, rhs: &::cpp_core::Ptr<::cpp_core::char32_t>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_67(
            self as *const crate::U32String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::String>> for crate::String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __lhs, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __rhs)```</span>.
    unsafe fn le(&self, rhs: &::cpp_core::Ref<crate::String>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__79(
            self as *const crate::String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::WString>> for crate::WString {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __lhs, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __rhs)```</span>.
    unsafe fn le(&self, rhs: &::cpp_core::Ref<crate::WString>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__80(
            self as *const crate::WString,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::U16String>> for crate::U16String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __lhs, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __rhs)```</span>.
    unsafe fn le(&self, rhs: &::cpp_core::Ref<crate::U16String>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__81(
            self as *const crate::U16String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::U32String>> for crate::U32String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __lhs, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __rhs)```</span>.
    unsafe fn le(&self, rhs: &::cpp_core::Ref<crate::U32String>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__82(
            self as *const crate::U32String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ptr<::std::os::raw::c_char>> for crate::String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __lhs, const char* __rhs)```</span>.
    unsafe fn le(&self, rhs: &::cpp_core::Ptr<::std::os::raw::c_char>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__83(
            self as *const crate::String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ptr<::cpp_core::wchar_t>> for crate::WString {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __lhs, const wchar_t* __rhs)```</span>.
    unsafe fn le(&self, rhs: &::cpp_core::Ptr<::cpp_core::wchar_t>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__84(
            self as *const crate::WString,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ptr<::cpp_core::char16_t>> for crate::U16String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __lhs, const char16_t* __rhs)```</span>.
    unsafe fn le(&self, rhs: &::cpp_core::Ptr<::cpp_core::char16_t>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__85(
            self as *const crate::U16String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ptr<::cpp_core::char32_t>> for crate::U32String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __lhs, const char32_t* __rhs)```</span>.
    unsafe fn le(&self, rhs: &::cpp_core::Ptr<::cpp_core::char32_t>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__86(
            self as *const crate::U32String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::String>> for crate::String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __lhs, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __rhs)```</span>.
    unsafe fn ge(&self, rhs: &::cpp_core::Ref<crate::String>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__91(
            self as *const crate::String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::WString>> for crate::WString {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __lhs, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __rhs)```</span>.
    unsafe fn ge(&self, rhs: &::cpp_core::Ref<crate::WString>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__92(
            self as *const crate::WString,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::U16String>> for crate::U16String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __lhs, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __rhs)```</span>.
    unsafe fn ge(&self, rhs: &::cpp_core::Ref<crate::U16String>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__93(
            self as *const crate::U16String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::U32String>> for crate::U32String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __lhs, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __rhs)```</span>.
    unsafe fn ge(&self, rhs: &::cpp_core::Ref<crate::U32String>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__94(
            self as *const crate::U32String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ptr<::std::os::raw::c_char>> for crate::String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __lhs, const char* __rhs)```</span>.
    unsafe fn ge(&self, rhs: &::cpp_core::Ptr<::std::os::raw::c_char>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__95(
            self as *const crate::String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ptr<::cpp_core::wchar_t>> for crate::WString {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __lhs, const wchar_t* __rhs)```</span>.
    unsafe fn ge(&self, rhs: &::cpp_core::Ptr<::cpp_core::wchar_t>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__96(
            self as *const crate::WString,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ptr<::cpp_core::char16_t>> for crate::U16String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __lhs, const char16_t* __rhs)```</span>.
    unsafe fn ge(&self, rhs: &::cpp_core::Ptr<::cpp_core::char16_t>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__97(
            self as *const crate::U16String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ptr<::cpp_core::char32_t>> for crate::U32String {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __lhs, const char32_t* __rhs)```</span>.
    unsafe fn ge(&self, rhs: &::cpp_core::Ptr<::cpp_core::char32_t>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__98(
            self as *const crate::U32String,
            rhs.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfBool {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<bool, std::allocator<bool>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_bool_std_allocator_bool_size(
            self as *const crate::VectorOfBool,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfChar {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<char, std::allocator<char>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_size(
            self as *const crate::VectorOfChar,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfSchar {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<signed char, std::allocator<signed char>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_size(
            self as *const crate::VectorOfSchar,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfUchar {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned char, std::allocator<unsigned char>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_size(
            self as *const crate::VectorOfUchar,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfWcharT {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<wchar_t, std::allocator<wchar_t>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_size(
            self as *const crate::VectorOfWcharT,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfChar16T {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<char16_t, std::allocator<char16_t>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_size(
            self as *const crate::VectorOfChar16T,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfChar32T {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<char32_t, std::allocator<char32_t>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_size(
            self as *const crate::VectorOfChar32T,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfShort {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<short, std::allocator<short>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_size(
            self as *const crate::VectorOfShort,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfUshort {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned short, std::allocator<unsigned short>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_size(
            self as *const crate::VectorOfUshort,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfInt {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int, std::allocator<int>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_size(
            self as *const crate::VectorOfInt,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfUint {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned int, std::allocator<unsigned int>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_size(
            self as *const crate::VectorOfUint,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfLong {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<long, std::allocator<long>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_size(
            self as *const crate::VectorOfLong,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfUlong {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned long, std::allocator<unsigned long>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_size(
            self as *const crate::VectorOfUlong,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfLonglong {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<long long, std::allocator<long long>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_size(
            self as *const crate::VectorOfLonglong,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfUlonglong {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<unsigned long long, std::allocator<unsigned long long>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_size(self as *const crate::VectorOfUlonglong)
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfFloat {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<float, std::allocator<float>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_size(
            self as *const crate::VectorOfFloat,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfDouble {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<double, std::allocator<double>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_size(
            self as *const crate::VectorOfDouble,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfI8 {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int8_t, std::allocator<int8_t>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_size(
            self as *const crate::VectorOfI8,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfU8 {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint8_t, std::allocator<uint8_t>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_size(
            self as *const crate::VectorOfU8,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfI16 {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int16_t, std::allocator<int16_t>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_size(
            self as *const crate::VectorOfI16,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfU16 {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint16_t, std::allocator<uint16_t>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_size(
            self as *const crate::VectorOfU16,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfI32 {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int32_t, std::allocator<int32_t>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_size(
            self as *const crate::VectorOfI32,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfU32 {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint32_t, std::allocator<uint32_t>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_size(
            self as *const crate::VectorOfU32,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfI64 {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<int64_t, std::allocator<int64_t>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_size(
            self as *const crate::VectorOfI64,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfU64 {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<uint64_t, std::allocator<uint64_t>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_size(
            self as *const crate::VectorOfU64,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfUsize {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<size_t, std::allocator<size_t>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_size(
            self as *const crate::VectorOfUsize,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::VectorOfVoid {
    /// Calls C++ function: <span style='color: green;'>```size_t std::vector<void*, std::allocator<void*>>::size() const```</span>.
    unsafe fn size(&self) -> usize {
        crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_size(
            self as *const crate::VectorOfVoid,
        )
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfChar {
    type Output = ::cpp_core::MutPtr<::std::os::raw::c_char>;
    /// Calls C++ function: <span style='color: green;'>```char* std::vector<char, std::allocator<char>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_data(
            self as *mut crate::VectorOfChar,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfSchar {
    type Output = ::cpp_core::MutPtr<::std::os::raw::c_schar>;
    /// Calls C++ function: <span style='color: green;'>```signed char* std::vector<signed char, std::allocator<signed char>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_schar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_data(
                self as *mut crate::VectorOfSchar,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfUchar {
    type Output = ::cpp_core::MutPtr<::std::os::raw::c_uchar>;
    /// Calls C++ function: <span style='color: green;'>```unsigned char* std::vector<unsigned char, std::allocator<unsigned char>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_uchar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_data(
                self as *mut crate::VectorOfUchar,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfWcharT {
    type Output = ::cpp_core::MutPtr<::cpp_core::wchar_t>;
    /// Calls C++ function: <span style='color: green;'>```wchar_t* std::vector<wchar_t, std::allocator<wchar_t>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::cpp_core::wchar_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_data(
                self as *mut crate::VectorOfWcharT,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfChar16T {
    type Output = ::cpp_core::MutPtr<::cpp_core::char16_t>;
    /// Calls C++ function: <span style='color: green;'>```char16_t* std::vector<char16_t, std::allocator<char16_t>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::cpp_core::char16_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_data(
                self as *mut crate::VectorOfChar16T,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfChar32T {
    type Output = ::cpp_core::MutPtr<::cpp_core::char32_t>;
    /// Calls C++ function: <span style='color: green;'>```char32_t* std::vector<char32_t, std::allocator<char32_t>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::cpp_core::char32_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_data(
                self as *mut crate::VectorOfChar32T,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfShort {
    type Output = ::cpp_core::MutPtr<::std::os::raw::c_short>;
    /// Calls C++ function: <span style='color: green;'>```short* std::vector<short, std::allocator<short>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_short> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_data(
            self as *mut crate::VectorOfShort,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfUshort {
    type Output = ::cpp_core::MutPtr<::std::os::raw::c_ushort>;
    /// Calls C++ function: <span style='color: green;'>```unsigned short* std::vector<unsigned short, std::allocator<unsigned short>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_ushort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_data(self as *mut crate::VectorOfUshort);
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfInt {
    type Output = ::cpp_core::MutPtr<::std::os::raw::c_int>;
    /// Calls C++ function: <span style='color: green;'>```int* std::vector<int, std::allocator<int>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_int> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_data(
            self as *mut crate::VectorOfInt,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfUint {
    type Output = ::cpp_core::MutPtr<::std::os::raw::c_uint>;
    /// Calls C++ function: <span style='color: green;'>```unsigned int* std::vector<unsigned int, std::allocator<unsigned int>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_uint> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_data(
                self as *mut crate::VectorOfUint,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfLong {
    type Output = ::cpp_core::MutPtr<::std::os::raw::c_long>;
    /// Calls C++ function: <span style='color: green;'>```long* std::vector<long, std::allocator<long>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_long> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_data(
            self as *mut crate::VectorOfLong,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfUlong {
    type Output = ::cpp_core::MutPtr<::std::os::raw::c_ulong>;
    /// Calls C++ function: <span style='color: green;'>```unsigned long* std::vector<unsigned long, std::allocator<unsigned long>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_ulong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_data(
                self as *mut crate::VectorOfUlong,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfLonglong {
    type Output = ::cpp_core::MutPtr<::std::os::raw::c_longlong>;
    /// Calls C++ function: <span style='color: green;'>```long long* std::vector<long long, std::allocator<long long>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_longlong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_data(
                self as *mut crate::VectorOfLonglong,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfUlonglong {
    type Output = ::cpp_core::MutPtr<::std::os::raw::c_ulonglong>;
    /// Calls C++ function: <span style='color: green;'>```unsigned long long* std::vector<unsigned long long, std::allocator<unsigned long long>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_ulonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_data(self as *mut crate::VectorOfUlonglong);
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfFloat {
    type Output = ::cpp_core::MutPtr<::std::os::raw::c_float>;
    /// Calls C++ function: <span style='color: green;'>```float* std::vector<float, std::allocator<float>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_float> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_data(
            self as *mut crate::VectorOfFloat,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfDouble {
    type Output = ::cpp_core::MutPtr<::std::os::raw::c_double>;
    /// Calls C++ function: <span style='color: green;'>```double* std::vector<double, std::allocator<double>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<::std::os::raw::c_double> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_data(
            self as *mut crate::VectorOfDouble,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfI8 {
    type Output = ::cpp_core::MutPtr<i8>;
    /// Calls C++ function: <span style='color: green;'>```int8_t* std::vector<int8_t, std::allocator<int8_t>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<i8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_data(
            self as *mut crate::VectorOfI8,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfU8 {
    type Output = ::cpp_core::MutPtr<u8>;
    /// Calls C++ function: <span style='color: green;'>```uint8_t* std::vector<uint8_t, std::allocator<uint8_t>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<u8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_data(
                self as *mut crate::VectorOfU8,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfI16 {
    type Output = ::cpp_core::MutPtr<i16>;
    /// Calls C++ function: <span style='color: green;'>```int16_t* std::vector<int16_t, std::allocator<int16_t>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<i16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_data(
                self as *mut crate::VectorOfI16,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfU16 {
    type Output = ::cpp_core::MutPtr<u16>;
    /// Calls C++ function: <span style='color: green;'>```uint16_t* std::vector<uint16_t, std::allocator<uint16_t>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<u16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_data(
                self as *mut crate::VectorOfU16,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfI32 {
    type Output = ::cpp_core::MutPtr<i32>;
    /// Calls C++ function: <span style='color: green;'>```int32_t* std::vector<int32_t, std::allocator<int32_t>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<i32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_data(
                self as *mut crate::VectorOfI32,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfU32 {
    type Output = ::cpp_core::MutPtr<u32>;
    /// Calls C++ function: <span style='color: green;'>```uint32_t* std::vector<uint32_t, std::allocator<uint32_t>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<u32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_data(
                self as *mut crate::VectorOfU32,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfI64 {
    type Output = ::cpp_core::MutPtr<i64>;
    /// Calls C++ function: <span style='color: green;'>```int64_t* std::vector<int64_t, std::allocator<int64_t>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<i64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_data(
                self as *mut crate::VectorOfI64,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfU64 {
    type Output = ::cpp_core::MutPtr<u64>;
    /// Calls C++ function: <span style='color: green;'>```uint64_t* std::vector<uint64_t, std::allocator<uint64_t>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<u64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_data(
                self as *mut crate::VectorOfU64,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfUsize {
    type Output = ::cpp_core::MutPtr<usize>;
    /// Calls C++ function: <span style='color: green;'>```size_t* std::vector<size_t, std::allocator<size_t>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<usize> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_data(
            self as *mut crate::VectorOfUsize,
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::DataMut for crate::VectorOfVoid {
    type Output = ::cpp_core::MutPtr<*mut ::std::ffi::c_void>;
    /// Calls C++ function: <span style='color: green;'>```void** std::vector<void*, std::allocator<void*>>::data()```</span>.
    unsafe fn data_mut(&mut self) -> ::cpp_core::MutPtr<*mut ::std::ffi::c_void> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_void_ptr_std_allocator_void_ptr_data(
                self as *mut crate::VectorOfVoid,
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfChar {
    type Output = ::cpp_core::Ptr<::std::os::raw::c_char>;
    /// Calls C++ function: <span style='color: green;'>```const char* std::vector<char, std::allocator<char>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_char> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_char_std_allocator_char_data1(
            self as *const crate::VectorOfChar,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfSchar {
    type Output = ::cpp_core::Ptr<::std::os::raw::c_schar>;
    /// Calls C++ function: <span style='color: green;'>```const signed char* std::vector<signed char, std::allocator<signed char>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_schar> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_signed_char_std_allocator_signed_char_data1(
                self as *const crate::VectorOfSchar,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfUchar {
    type Output = ::cpp_core::Ptr<::std::os::raw::c_uchar>;
    /// Calls C++ function: <span style='color: green;'>```const unsigned char* std::vector<unsigned char, std::allocator<unsigned char>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_uchar> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_char_std_allocator_unsigned_char_data1(self as *const crate::VectorOfUchar);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfWcharT {
    type Output = ::cpp_core::Ptr<::cpp_core::wchar_t>;
    /// Calls C++ function: <span style='color: green;'>```const wchar_t* std::vector<wchar_t, std::allocator<wchar_t>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::cpp_core::wchar_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_wchar_t_std_allocator_wchar_t_data1(
                self as *const crate::VectorOfWcharT,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfChar16T {
    type Output = ::cpp_core::Ptr<::cpp_core::char16_t>;
    /// Calls C++ function: <span style='color: green;'>```const char16_t* std::vector<char16_t, std::allocator<char16_t>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::cpp_core::char16_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char16_t_std_allocator_char16_t_data1(
                self as *const crate::VectorOfChar16T,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfChar32T {
    type Output = ::cpp_core::Ptr<::cpp_core::char32_t>;
    /// Calls C++ function: <span style='color: green;'>```const char32_t* std::vector<char32_t, std::allocator<char32_t>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::cpp_core::char32_t> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_char32_t_std_allocator_char32_t_data1(
                self as *const crate::VectorOfChar32T,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfShort {
    type Output = ::cpp_core::Ptr<::std::os::raw::c_short>;
    /// Calls C++ function: <span style='color: green;'>```const short* std::vector<short, std::allocator<short>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_short> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_short_std_allocator_short_data1(
            self as *const crate::VectorOfShort,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfUshort {
    type Output = ::cpp_core::Ptr<::std::os::raw::c_ushort>;
    /// Calls C++ function: <span style='color: green;'>```const unsigned short* std::vector<unsigned short, std::allocator<unsigned short>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_ushort> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_short_std_allocator_unsigned_short_data1(self as *const crate::VectorOfUshort);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfInt {
    type Output = ::cpp_core::Ptr<::std::os::raw::c_int>;
    /// Calls C++ function: <span style='color: green;'>```const int* std::vector<int, std::allocator<int>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_int> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int_std_allocator_int_data1(
            self as *const crate::VectorOfInt,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfUint {
    type Output = ::cpp_core::Ptr<::std::os::raw::c_uint>;
    /// Calls C++ function: <span style='color: green;'>```const unsigned int* std::vector<unsigned int, std::allocator<unsigned int>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_uint> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_int_std_allocator_unsigned_int_data1(
                self as *const crate::VectorOfUint,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfLong {
    type Output = ::cpp_core::Ptr<::std::os::raw::c_long>;
    /// Calls C++ function: <span style='color: green;'>```const long* std::vector<long, std::allocator<long>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_long> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_long_std_allocator_long_data1(
            self as *const crate::VectorOfLong,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfUlong {
    type Output = ::cpp_core::Ptr<::std::os::raw::c_ulong>;
    /// Calls C++ function: <span style='color: green;'>```const unsigned long* std::vector<unsigned long, std::allocator<unsigned long>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_ulong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_std_allocator_unsigned_long_data1(self as *const crate::VectorOfUlong);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfLonglong {
    type Output = ::cpp_core::Ptr<::std::os::raw::c_longlong>;
    /// Calls C++ function: <span style='color: green;'>```const long long* std::vector<long long, std::allocator<long long>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_longlong> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_long_long_std_allocator_long_long_data1(
                self as *const crate::VectorOfLonglong,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfUlonglong {
    type Output = ::cpp_core::Ptr<::std::os::raw::c_ulonglong>;
    /// Calls C++ function: <span style='color: green;'>```const unsigned long long* std::vector<unsigned long long, std::allocator<unsigned long long>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_ulonglong> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_unsigned_long_long_std_allocator_unsigned_long_long_data1(self as *const crate::VectorOfUlonglong);
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfFloat {
    type Output = ::cpp_core::Ptr<::std::os::raw::c_float>;
    /// Calls C++ function: <span style='color: green;'>```const float* std::vector<float, std::allocator<float>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_float> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_float_std_allocator_float_data1(
            self as *const crate::VectorOfFloat,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfDouble {
    type Output = ::cpp_core::Ptr<::std::os::raw::c_double>;
    /// Calls C++ function: <span style='color: green;'>```const double* std::vector<double, std::allocator<double>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<::std::os::raw::c_double> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_double_std_allocator_double_data1(
            self as *const crate::VectorOfDouble,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfI8 {
    type Output = ::cpp_core::Ptr<i8>;
    /// Calls C++ function: <span style='color: green;'>```const int8_t* std::vector<int8_t, std::allocator<int8_t>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<i8> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_int8_t_std_allocator_int8_t_data1(
            self as *const crate::VectorOfI8,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfU8 {
    type Output = ::cpp_core::Ptr<u8>;
    /// Calls C++ function: <span style='color: green;'>```const uint8_t* std::vector<uint8_t, std::allocator<uint8_t>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<u8> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint8_t_std_allocator_uint8_t_data1(
                self as *const crate::VectorOfU8,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfI16 {
    type Output = ::cpp_core::Ptr<i16>;
    /// Calls C++ function: <span style='color: green;'>```const int16_t* std::vector<int16_t, std::allocator<int16_t>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<i16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int16_t_std_allocator_int16_t_data1(
                self as *const crate::VectorOfI16,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfU16 {
    type Output = ::cpp_core::Ptr<u16>;
    /// Calls C++ function: <span style='color: green;'>```const uint16_t* std::vector<uint16_t, std::allocator<uint16_t>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<u16> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint16_t_std_allocator_uint16_t_data1(
                self as *const crate::VectorOfU16,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfI32 {
    type Output = ::cpp_core::Ptr<i32>;
    /// Calls C++ function: <span style='color: green;'>```const int32_t* std::vector<int32_t, std::allocator<int32_t>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<i32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int32_t_std_allocator_int32_t_data1(
                self as *const crate::VectorOfI32,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfU32 {
    type Output = ::cpp_core::Ptr<u32>;
    /// Calls C++ function: <span style='color: green;'>```const uint32_t* std::vector<uint32_t, std::allocator<uint32_t>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<u32> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint32_t_std_allocator_uint32_t_data1(
                self as *const crate::VectorOfU32,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfI64 {
    type Output = ::cpp_core::Ptr<i64>;
    /// Calls C++ function: <span style='color: green;'>```const int64_t* std::vector<int64_t, std::allocator<int64_t>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<i64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_int64_t_std_allocator_int64_t_data1(
                self as *const crate::VectorOfI64,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfU64 {
    type Output = ::cpp_core::Ptr<u64>;
    /// Calls C++ function: <span style='color: green;'>```const uint64_t* std::vector<uint64_t, std::allocator<uint64_t>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<u64> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_std_vector_uint64_t_std_allocator_uint64_t_data1(
                self as *const crate::VectorOfU64,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::VectorOfUsize {
    type Output = ::cpp_core::Ptr<usize>;
    /// Calls C++ function: <span style='color: green;'>```const size_t* std::vector<size_t, std::allocator<size_t>>::data() const```</span>.
    unsafe fn data(&self) -> ::cpp_core::Ptr<usize> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_vector_size_t_std_allocator_size_t_data1(
            self as *const crate::VectorOfUsize,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfBool>> for crate::VectorOfBool {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<bool, std::allocator<bool>>& __x, const std::vector<bool, std::allocator<bool>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfBool>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__103(
                self as *const crate::VectorOfBool,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfChar>> for crate::VectorOfChar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<char, std::allocator<char>>& __x, const std::vector<char, std::allocator<char>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfChar>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__104(
                self as *const crate::VectorOfChar,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfSchar>> for crate::VectorOfSchar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<signed char, std::allocator<signed char>>& __x, const std::vector<signed char, std::allocator<signed char>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfSchar>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__105(
                self as *const crate::VectorOfSchar,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfUchar>> for crate::VectorOfUchar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<unsigned char, std::allocator<unsigned char>>& __x, const std::vector<unsigned char, std::allocator<unsigned char>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfUchar>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__106(
                self as *const crate::VectorOfUchar,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfWcharT>> for crate::VectorOfWcharT {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<wchar_t, std::allocator<wchar_t>>& __x, const std::vector<wchar_t, std::allocator<wchar_t>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfWcharT>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__107(
                self as *const crate::VectorOfWcharT,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfChar16T>> for crate::VectorOfChar16T {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<char16_t, std::allocator<char16_t>>& __x, const std::vector<char16_t, std::allocator<char16_t>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfChar16T>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__108(
                self as *const crate::VectorOfChar16T,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfChar32T>> for crate::VectorOfChar32T {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<char32_t, std::allocator<char32_t>>& __x, const std::vector<char32_t, std::allocator<char32_t>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfChar32T>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__109(
                self as *const crate::VectorOfChar32T,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfShort>> for crate::VectorOfShort {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<short, std::allocator<short>>& __x, const std::vector<short, std::allocator<short>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfShort>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__110(
                self as *const crate::VectorOfShort,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfUshort>> for crate::VectorOfUshort {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<unsigned short, std::allocator<unsigned short>>& __x, const std::vector<unsigned short, std::allocator<unsigned short>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfUshort>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__111(
                self as *const crate::VectorOfUshort,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfInt>> for crate::VectorOfInt {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<int, std::allocator<int>>& __x, const std::vector<int, std::allocator<int>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfInt>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__112(
                self as *const crate::VectorOfInt,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfUint>> for crate::VectorOfUint {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<unsigned int, std::allocator<unsigned int>>& __x, const std::vector<unsigned int, std::allocator<unsigned int>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfUint>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__113(
                self as *const crate::VectorOfUint,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfLong>> for crate::VectorOfLong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<long, std::allocator<long>>& __x, const std::vector<long, std::allocator<long>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfLong>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__114(
                self as *const crate::VectorOfLong,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfUlong>> for crate::VectorOfUlong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<unsigned long, std::allocator<unsigned long>>& __x, const std::vector<unsigned long, std::allocator<unsigned long>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfUlong>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__115(
                self as *const crate::VectorOfUlong,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfLonglong>> for crate::VectorOfLonglong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<long long, std::allocator<long long>>& __x, const std::vector<long long, std::allocator<long long>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfLonglong>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__116(
                self as *const crate::VectorOfLonglong,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfUlonglong>> for crate::VectorOfUlonglong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<unsigned long long, std::allocator<unsigned long long>>& __x, const std::vector<unsigned long long, std::allocator<unsigned long long>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfUlonglong>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__117(
                self as *const crate::VectorOfUlonglong,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfFloat>> for crate::VectorOfFloat {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<float, std::allocator<float>>& __x, const std::vector<float, std::allocator<float>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfFloat>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__118(
                self as *const crate::VectorOfFloat,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfDouble>> for crate::VectorOfDouble {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<double, std::allocator<double>>& __x, const std::vector<double, std::allocator<double>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfDouble>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__119(
                self as *const crate::VectorOfDouble,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfI8>> for crate::VectorOfI8 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<int8_t, std::allocator<int8_t>>& __x, const std::vector<int8_t, std::allocator<int8_t>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfI8>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__120(
                self as *const crate::VectorOfI8,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfU8>> for crate::VectorOfU8 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<uint8_t, std::allocator<uint8_t>>& __x, const std::vector<uint8_t, std::allocator<uint8_t>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfU8>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__121(
                self as *const crate::VectorOfU8,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfI16>> for crate::VectorOfI16 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<int16_t, std::allocator<int16_t>>& __x, const std::vector<int16_t, std::allocator<int16_t>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfI16>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__122(
                self as *const crate::VectorOfI16,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfU16>> for crate::VectorOfU16 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<uint16_t, std::allocator<uint16_t>>& __x, const std::vector<uint16_t, std::allocator<uint16_t>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfU16>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__123(
                self as *const crate::VectorOfU16,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfI32>> for crate::VectorOfI32 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<int32_t, std::allocator<int32_t>>& __x, const std::vector<int32_t, std::allocator<int32_t>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfI32>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__124(
                self as *const crate::VectorOfI32,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfU32>> for crate::VectorOfU32 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<uint32_t, std::allocator<uint32_t>>& __x, const std::vector<uint32_t, std::allocator<uint32_t>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfU32>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__125(
                self as *const crate::VectorOfU32,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfI64>> for crate::VectorOfI64 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<int64_t, std::allocator<int64_t>>& __x, const std::vector<int64_t, std::allocator<int64_t>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfI64>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__126(
                self as *const crate::VectorOfI64,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfU64>> for crate::VectorOfU64 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<uint64_t, std::allocator<uint64_t>>& __x, const std::vector<uint64_t, std::allocator<uint64_t>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfU64>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__127(
                self as *const crate::VectorOfU64,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfUsize>> for crate::VectorOfUsize {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<size_t, std::allocator<size_t>>& __x, const std::vector<size_t, std::allocator<size_t>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfUsize>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__128(
                self as *const crate::VectorOfUsize,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::VectorOfVoid>> for crate::VectorOfVoid {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator==(const std::vector<void*, std::allocator<void*>>& __x, const std::vector<void*, std::allocator<void*>>& __y)```</span>.
    fn eq(&self, y: &::cpp_core::Ref<crate::VectorOfVoid>) -> bool {
        unsafe {
            crate::__ffi::ctr_cpp_std_ffi_std_operator__129(
                self as *const crate::VectorOfVoid,
                y.as_raw_ptr(),
            )
        }
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfBool>> for crate::VectorOfBool {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<bool, std::allocator<bool>>& __x, const std::vector<bool, std::allocator<bool>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfBool>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_72(
            self as *const crate::VectorOfBool,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfChar>> for crate::VectorOfChar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<char, std::allocator<char>>& __x, const std::vector<char, std::allocator<char>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfChar>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_73(
            self as *const crate::VectorOfChar,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfSchar>> for crate::VectorOfSchar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<signed char, std::allocator<signed char>>& __x, const std::vector<signed char, std::allocator<signed char>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfSchar>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_74(
            self as *const crate::VectorOfSchar,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfUchar>> for crate::VectorOfUchar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<unsigned char, std::allocator<unsigned char>>& __x, const std::vector<unsigned char, std::allocator<unsigned char>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfUchar>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_75(
            self as *const crate::VectorOfUchar,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfWcharT>> for crate::VectorOfWcharT {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<wchar_t, std::allocator<wchar_t>>& __x, const std::vector<wchar_t, std::allocator<wchar_t>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfWcharT>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_76(
            self as *const crate::VectorOfWcharT,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfChar16T>> for crate::VectorOfChar16T {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<char16_t, std::allocator<char16_t>>& __x, const std::vector<char16_t, std::allocator<char16_t>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfChar16T>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_77(
            self as *const crate::VectorOfChar16T,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfChar32T>> for crate::VectorOfChar32T {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<char32_t, std::allocator<char32_t>>& __x, const std::vector<char32_t, std::allocator<char32_t>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfChar32T>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_78(
            self as *const crate::VectorOfChar32T,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfShort>> for crate::VectorOfShort {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<short, std::allocator<short>>& __x, const std::vector<short, std::allocator<short>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfShort>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_79(
            self as *const crate::VectorOfShort,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfUshort>> for crate::VectorOfUshort {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<unsigned short, std::allocator<unsigned short>>& __x, const std::vector<unsigned short, std::allocator<unsigned short>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfUshort>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_80(
            self as *const crate::VectorOfUshort,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfInt>> for crate::VectorOfInt {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<int, std::allocator<int>>& __x, const std::vector<int, std::allocator<int>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfInt>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_81(
            self as *const crate::VectorOfInt,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfUint>> for crate::VectorOfUint {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<unsigned int, std::allocator<unsigned int>>& __x, const std::vector<unsigned int, std::allocator<unsigned int>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfUint>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_82(
            self as *const crate::VectorOfUint,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfLong>> for crate::VectorOfLong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<long, std::allocator<long>>& __x, const std::vector<long, std::allocator<long>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfLong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_83(
            self as *const crate::VectorOfLong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfUlong>> for crate::VectorOfUlong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<unsigned long, std::allocator<unsigned long>>& __x, const std::vector<unsigned long, std::allocator<unsigned long>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfUlong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_84(
            self as *const crate::VectorOfUlong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfLonglong>> for crate::VectorOfLonglong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<long long, std::allocator<long long>>& __x, const std::vector<long long, std::allocator<long long>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfLonglong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_85(
            self as *const crate::VectorOfLonglong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfUlonglong>> for crate::VectorOfUlonglong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<unsigned long long, std::allocator<unsigned long long>>& __x, const std::vector<unsigned long long, std::allocator<unsigned long long>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfUlonglong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_86(
            self as *const crate::VectorOfUlonglong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfFloat>> for crate::VectorOfFloat {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<float, std::allocator<float>>& __x, const std::vector<float, std::allocator<float>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfFloat>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_87(
            self as *const crate::VectorOfFloat,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfDouble>> for crate::VectorOfDouble {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<double, std::allocator<double>>& __x, const std::vector<double, std::allocator<double>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfDouble>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_88(
            self as *const crate::VectorOfDouble,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfI8>> for crate::VectorOfI8 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<int8_t, std::allocator<int8_t>>& __x, const std::vector<int8_t, std::allocator<int8_t>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfI8>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_89(
            self as *const crate::VectorOfI8,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfU8>> for crate::VectorOfU8 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<uint8_t, std::allocator<uint8_t>>& __x, const std::vector<uint8_t, std::allocator<uint8_t>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfU8>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_90(
            self as *const crate::VectorOfU8,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfI16>> for crate::VectorOfI16 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<int16_t, std::allocator<int16_t>>& __x, const std::vector<int16_t, std::allocator<int16_t>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfI16>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_91(
            self as *const crate::VectorOfI16,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfU16>> for crate::VectorOfU16 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<uint16_t, std::allocator<uint16_t>>& __x, const std::vector<uint16_t, std::allocator<uint16_t>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfU16>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_92(
            self as *const crate::VectorOfU16,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfI32>> for crate::VectorOfI32 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<int32_t, std::allocator<int32_t>>& __x, const std::vector<int32_t, std::allocator<int32_t>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfI32>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_93(
            self as *const crate::VectorOfI32,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfU32>> for crate::VectorOfU32 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<uint32_t, std::allocator<uint32_t>>& __x, const std::vector<uint32_t, std::allocator<uint32_t>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfU32>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_94(
            self as *const crate::VectorOfU32,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfI64>> for crate::VectorOfI64 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<int64_t, std::allocator<int64_t>>& __x, const std::vector<int64_t, std::allocator<int64_t>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfI64>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_95(
            self as *const crate::VectorOfI64,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfU64>> for crate::VectorOfU64 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<uint64_t, std::allocator<uint64_t>>& __x, const std::vector<uint64_t, std::allocator<uint64_t>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfU64>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_96(
            self as *const crate::VectorOfU64,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfUsize>> for crate::VectorOfUsize {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<size_t, std::allocator<size_t>>& __x, const std::vector<size_t, std::allocator<size_t>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfUsize>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_97(
            self as *const crate::VectorOfUsize,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::VectorOfVoid>> for crate::VectorOfVoid {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<(const std::vector<void*, std::allocator<void*>>& __x, const std::vector<void*, std::allocator<void*>>& __y)```</span>.
    unsafe fn lt(&self, y: &::cpp_core::Ref<crate::VectorOfVoid>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_98(
            self as *const crate::VectorOfVoid,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfBool>> for crate::VectorOfBool {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<bool, std::allocator<bool>>& __x, const std::vector<bool, std::allocator<bool>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfBool>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_99(
            self as *const crate::VectorOfBool,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfChar>> for crate::VectorOfChar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<char, std::allocator<char>>& __x, const std::vector<char, std::allocator<char>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfChar>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_100(
            self as *const crate::VectorOfChar,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfSchar>> for crate::VectorOfSchar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<signed char, std::allocator<signed char>>& __x, const std::vector<signed char, std::allocator<signed char>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfSchar>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_101(
            self as *const crate::VectorOfSchar,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfUchar>> for crate::VectorOfUchar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<unsigned char, std::allocator<unsigned char>>& __x, const std::vector<unsigned char, std::allocator<unsigned char>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfUchar>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_102(
            self as *const crate::VectorOfUchar,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfWcharT>> for crate::VectorOfWcharT {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<wchar_t, std::allocator<wchar_t>>& __x, const std::vector<wchar_t, std::allocator<wchar_t>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfWcharT>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_103(
            self as *const crate::VectorOfWcharT,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfChar16T>> for crate::VectorOfChar16T {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<char16_t, std::allocator<char16_t>>& __x, const std::vector<char16_t, std::allocator<char16_t>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfChar16T>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_104(
            self as *const crate::VectorOfChar16T,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfChar32T>> for crate::VectorOfChar32T {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<char32_t, std::allocator<char32_t>>& __x, const std::vector<char32_t, std::allocator<char32_t>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfChar32T>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_105(
            self as *const crate::VectorOfChar32T,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfShort>> for crate::VectorOfShort {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<short, std::allocator<short>>& __x, const std::vector<short, std::allocator<short>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfShort>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_106(
            self as *const crate::VectorOfShort,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfUshort>> for crate::VectorOfUshort {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<unsigned short, std::allocator<unsigned short>>& __x, const std::vector<unsigned short, std::allocator<unsigned short>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfUshort>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_107(
            self as *const crate::VectorOfUshort,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfInt>> for crate::VectorOfInt {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<int, std::allocator<int>>& __x, const std::vector<int, std::allocator<int>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfInt>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_108(
            self as *const crate::VectorOfInt,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfUint>> for crate::VectorOfUint {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<unsigned int, std::allocator<unsigned int>>& __x, const std::vector<unsigned int, std::allocator<unsigned int>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfUint>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_109(
            self as *const crate::VectorOfUint,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfLong>> for crate::VectorOfLong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<long, std::allocator<long>>& __x, const std::vector<long, std::allocator<long>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfLong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_110(
            self as *const crate::VectorOfLong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfUlong>> for crate::VectorOfUlong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<unsigned long, std::allocator<unsigned long>>& __x, const std::vector<unsigned long, std::allocator<unsigned long>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfUlong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_111(
            self as *const crate::VectorOfUlong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfLonglong>> for crate::VectorOfLonglong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<long long, std::allocator<long long>>& __x, const std::vector<long long, std::allocator<long long>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfLonglong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_112(
            self as *const crate::VectorOfLonglong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfUlonglong>> for crate::VectorOfUlonglong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<unsigned long long, std::allocator<unsigned long long>>& __x, const std::vector<unsigned long long, std::allocator<unsigned long long>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfUlonglong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_113(
            self as *const crate::VectorOfUlonglong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfFloat>> for crate::VectorOfFloat {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<float, std::allocator<float>>& __x, const std::vector<float, std::allocator<float>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfFloat>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_114(
            self as *const crate::VectorOfFloat,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfDouble>> for crate::VectorOfDouble {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<double, std::allocator<double>>& __x, const std::vector<double, std::allocator<double>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfDouble>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_115(
            self as *const crate::VectorOfDouble,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfI8>> for crate::VectorOfI8 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<int8_t, std::allocator<int8_t>>& __x, const std::vector<int8_t, std::allocator<int8_t>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfI8>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_116(
            self as *const crate::VectorOfI8,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfU8>> for crate::VectorOfU8 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<uint8_t, std::allocator<uint8_t>>& __x, const std::vector<uint8_t, std::allocator<uint8_t>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfU8>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_117(
            self as *const crate::VectorOfU8,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfI16>> for crate::VectorOfI16 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<int16_t, std::allocator<int16_t>>& __x, const std::vector<int16_t, std::allocator<int16_t>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfI16>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_118(
            self as *const crate::VectorOfI16,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfU16>> for crate::VectorOfU16 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<uint16_t, std::allocator<uint16_t>>& __x, const std::vector<uint16_t, std::allocator<uint16_t>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfU16>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_119(
            self as *const crate::VectorOfU16,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfI32>> for crate::VectorOfI32 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<int32_t, std::allocator<int32_t>>& __x, const std::vector<int32_t, std::allocator<int32_t>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfI32>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_120(
            self as *const crate::VectorOfI32,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfU32>> for crate::VectorOfU32 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<uint32_t, std::allocator<uint32_t>>& __x, const std::vector<uint32_t, std::allocator<uint32_t>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfU32>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_121(
            self as *const crate::VectorOfU32,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfI64>> for crate::VectorOfI64 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<int64_t, std::allocator<int64_t>>& __x, const std::vector<int64_t, std::allocator<int64_t>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfI64>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_122(
            self as *const crate::VectorOfI64,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfU64>> for crate::VectorOfU64 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<uint64_t, std::allocator<uint64_t>>& __x, const std::vector<uint64_t, std::allocator<uint64_t>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfU64>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_123(
            self as *const crate::VectorOfU64,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfUsize>> for crate::VectorOfUsize {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<size_t, std::allocator<size_t>>& __x, const std::vector<size_t, std::allocator<size_t>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfUsize>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_124(
            self as *const crate::VectorOfUsize,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::VectorOfVoid>> for crate::VectorOfVoid {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>(const std::vector<void*, std::allocator<void*>>& __x, const std::vector<void*, std::allocator<void*>>& __y)```</span>.
    unsafe fn gt(&self, y: &::cpp_core::Ref<crate::VectorOfVoid>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator_125(
            self as *const crate::VectorOfVoid,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfBool>> for crate::VectorOfBool {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<bool, std::allocator<bool>>& __x, const std::vector<bool, std::allocator<bool>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfBool>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__157(
            self as *const crate::VectorOfBool,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfChar>> for crate::VectorOfChar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<char, std::allocator<char>>& __x, const std::vector<char, std::allocator<char>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfChar>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__158(
            self as *const crate::VectorOfChar,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfSchar>> for crate::VectorOfSchar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<signed char, std::allocator<signed char>>& __x, const std::vector<signed char, std::allocator<signed char>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfSchar>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__159(
            self as *const crate::VectorOfSchar,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfUchar>> for crate::VectorOfUchar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<unsigned char, std::allocator<unsigned char>>& __x, const std::vector<unsigned char, std::allocator<unsigned char>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfUchar>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__160(
            self as *const crate::VectorOfUchar,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfWcharT>> for crate::VectorOfWcharT {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<wchar_t, std::allocator<wchar_t>>& __x, const std::vector<wchar_t, std::allocator<wchar_t>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfWcharT>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__161(
            self as *const crate::VectorOfWcharT,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfChar16T>> for crate::VectorOfChar16T {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<char16_t, std::allocator<char16_t>>& __x, const std::vector<char16_t, std::allocator<char16_t>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfChar16T>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__162(
            self as *const crate::VectorOfChar16T,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfChar32T>> for crate::VectorOfChar32T {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<char32_t, std::allocator<char32_t>>& __x, const std::vector<char32_t, std::allocator<char32_t>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfChar32T>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__163(
            self as *const crate::VectorOfChar32T,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfShort>> for crate::VectorOfShort {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<short, std::allocator<short>>& __x, const std::vector<short, std::allocator<short>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfShort>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__164(
            self as *const crate::VectorOfShort,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfUshort>> for crate::VectorOfUshort {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<unsigned short, std::allocator<unsigned short>>& __x, const std::vector<unsigned short, std::allocator<unsigned short>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfUshort>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__165(
            self as *const crate::VectorOfUshort,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfInt>> for crate::VectorOfInt {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<int, std::allocator<int>>& __x, const std::vector<int, std::allocator<int>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfInt>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__166(
            self as *const crate::VectorOfInt,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfUint>> for crate::VectorOfUint {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<unsigned int, std::allocator<unsigned int>>& __x, const std::vector<unsigned int, std::allocator<unsigned int>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfUint>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__167(
            self as *const crate::VectorOfUint,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfLong>> for crate::VectorOfLong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<long, std::allocator<long>>& __x, const std::vector<long, std::allocator<long>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfLong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__168(
            self as *const crate::VectorOfLong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfUlong>> for crate::VectorOfUlong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<unsigned long, std::allocator<unsigned long>>& __x, const std::vector<unsigned long, std::allocator<unsigned long>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfUlong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__169(
            self as *const crate::VectorOfUlong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfLonglong>> for crate::VectorOfLonglong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<long long, std::allocator<long long>>& __x, const std::vector<long long, std::allocator<long long>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfLonglong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__170(
            self as *const crate::VectorOfLonglong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfUlonglong>> for crate::VectorOfUlonglong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<unsigned long long, std::allocator<unsigned long long>>& __x, const std::vector<unsigned long long, std::allocator<unsigned long long>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfUlonglong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__171(
            self as *const crate::VectorOfUlonglong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfFloat>> for crate::VectorOfFloat {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<float, std::allocator<float>>& __x, const std::vector<float, std::allocator<float>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfFloat>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__172(
            self as *const crate::VectorOfFloat,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfDouble>> for crate::VectorOfDouble {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<double, std::allocator<double>>& __x, const std::vector<double, std::allocator<double>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfDouble>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__173(
            self as *const crate::VectorOfDouble,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfI8>> for crate::VectorOfI8 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<int8_t, std::allocator<int8_t>>& __x, const std::vector<int8_t, std::allocator<int8_t>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfI8>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__174(
            self as *const crate::VectorOfI8,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfU8>> for crate::VectorOfU8 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<uint8_t, std::allocator<uint8_t>>& __x, const std::vector<uint8_t, std::allocator<uint8_t>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfU8>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__175(
            self as *const crate::VectorOfU8,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfI16>> for crate::VectorOfI16 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<int16_t, std::allocator<int16_t>>& __x, const std::vector<int16_t, std::allocator<int16_t>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfI16>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__176(
            self as *const crate::VectorOfI16,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfU16>> for crate::VectorOfU16 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<uint16_t, std::allocator<uint16_t>>& __x, const std::vector<uint16_t, std::allocator<uint16_t>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfU16>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__177(
            self as *const crate::VectorOfU16,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfI32>> for crate::VectorOfI32 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<int32_t, std::allocator<int32_t>>& __x, const std::vector<int32_t, std::allocator<int32_t>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfI32>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__178(
            self as *const crate::VectorOfI32,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfU32>> for crate::VectorOfU32 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<uint32_t, std::allocator<uint32_t>>& __x, const std::vector<uint32_t, std::allocator<uint32_t>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfU32>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__179(
            self as *const crate::VectorOfU32,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfI64>> for crate::VectorOfI64 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<int64_t, std::allocator<int64_t>>& __x, const std::vector<int64_t, std::allocator<int64_t>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfI64>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__180(
            self as *const crate::VectorOfI64,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfU64>> for crate::VectorOfU64 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<uint64_t, std::allocator<uint64_t>>& __x, const std::vector<uint64_t, std::allocator<uint64_t>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfU64>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__181(
            self as *const crate::VectorOfU64,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfUsize>> for crate::VectorOfUsize {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<size_t, std::allocator<size_t>>& __x, const std::vector<size_t, std::allocator<size_t>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfUsize>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__182(
            self as *const crate::VectorOfUsize,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::VectorOfVoid>> for crate::VectorOfVoid {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const std::vector<void*, std::allocator<void*>>& __x, const std::vector<void*, std::allocator<void*>>& __y)```</span>.
    unsafe fn le(&self, y: &::cpp_core::Ref<crate::VectorOfVoid>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__183(
            self as *const crate::VectorOfVoid,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfBool>> for crate::VectorOfBool {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<bool, std::allocator<bool>>& __x, const std::vector<bool, std::allocator<bool>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfBool>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__184(
            self as *const crate::VectorOfBool,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfChar>> for crate::VectorOfChar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<char, std::allocator<char>>& __x, const std::vector<char, std::allocator<char>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfChar>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__185(
            self as *const crate::VectorOfChar,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfSchar>> for crate::VectorOfSchar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<signed char, std::allocator<signed char>>& __x, const std::vector<signed char, std::allocator<signed char>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfSchar>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__186(
            self as *const crate::VectorOfSchar,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfUchar>> for crate::VectorOfUchar {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<unsigned char, std::allocator<unsigned char>>& __x, const std::vector<unsigned char, std::allocator<unsigned char>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfUchar>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__187(
            self as *const crate::VectorOfUchar,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfWcharT>> for crate::VectorOfWcharT {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<wchar_t, std::allocator<wchar_t>>& __x, const std::vector<wchar_t, std::allocator<wchar_t>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfWcharT>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__188(
            self as *const crate::VectorOfWcharT,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfChar16T>> for crate::VectorOfChar16T {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<char16_t, std::allocator<char16_t>>& __x, const std::vector<char16_t, std::allocator<char16_t>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfChar16T>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__189(
            self as *const crate::VectorOfChar16T,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfChar32T>> for crate::VectorOfChar32T {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<char32_t, std::allocator<char32_t>>& __x, const std::vector<char32_t, std::allocator<char32_t>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfChar32T>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__190(
            self as *const crate::VectorOfChar32T,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfShort>> for crate::VectorOfShort {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<short, std::allocator<short>>& __x, const std::vector<short, std::allocator<short>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfShort>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__191(
            self as *const crate::VectorOfShort,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfUshort>> for crate::VectorOfUshort {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<unsigned short, std::allocator<unsigned short>>& __x, const std::vector<unsigned short, std::allocator<unsigned short>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfUshort>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__192(
            self as *const crate::VectorOfUshort,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfInt>> for crate::VectorOfInt {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<int, std::allocator<int>>& __x, const std::vector<int, std::allocator<int>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfInt>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__193(
            self as *const crate::VectorOfInt,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfUint>> for crate::VectorOfUint {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<unsigned int, std::allocator<unsigned int>>& __x, const std::vector<unsigned int, std::allocator<unsigned int>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfUint>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__194(
            self as *const crate::VectorOfUint,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfLong>> for crate::VectorOfLong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<long, std::allocator<long>>& __x, const std::vector<long, std::allocator<long>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfLong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__195(
            self as *const crate::VectorOfLong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfUlong>> for crate::VectorOfUlong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<unsigned long, std::allocator<unsigned long>>& __x, const std::vector<unsigned long, std::allocator<unsigned long>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfUlong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__196(
            self as *const crate::VectorOfUlong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfLonglong>> for crate::VectorOfLonglong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<long long, std::allocator<long long>>& __x, const std::vector<long long, std::allocator<long long>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfLonglong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__197(
            self as *const crate::VectorOfLonglong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfUlonglong>> for crate::VectorOfUlonglong {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<unsigned long long, std::allocator<unsigned long long>>& __x, const std::vector<unsigned long long, std::allocator<unsigned long long>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfUlonglong>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__198(
            self as *const crate::VectorOfUlonglong,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfFloat>> for crate::VectorOfFloat {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<float, std::allocator<float>>& __x, const std::vector<float, std::allocator<float>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfFloat>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__199(
            self as *const crate::VectorOfFloat,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfDouble>> for crate::VectorOfDouble {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<double, std::allocator<double>>& __x, const std::vector<double, std::allocator<double>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfDouble>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__200(
            self as *const crate::VectorOfDouble,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfI8>> for crate::VectorOfI8 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<int8_t, std::allocator<int8_t>>& __x, const std::vector<int8_t, std::allocator<int8_t>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfI8>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__201(
            self as *const crate::VectorOfI8,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfU8>> for crate::VectorOfU8 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<uint8_t, std::allocator<uint8_t>>& __x, const std::vector<uint8_t, std::allocator<uint8_t>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfU8>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__202(
            self as *const crate::VectorOfU8,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfI16>> for crate::VectorOfI16 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<int16_t, std::allocator<int16_t>>& __x, const std::vector<int16_t, std::allocator<int16_t>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfI16>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__203(
            self as *const crate::VectorOfI16,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfU16>> for crate::VectorOfU16 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<uint16_t, std::allocator<uint16_t>>& __x, const std::vector<uint16_t, std::allocator<uint16_t>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfU16>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__204(
            self as *const crate::VectorOfU16,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfI32>> for crate::VectorOfI32 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<int32_t, std::allocator<int32_t>>& __x, const std::vector<int32_t, std::allocator<int32_t>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfI32>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__205(
            self as *const crate::VectorOfI32,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfU32>> for crate::VectorOfU32 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<uint32_t, std::allocator<uint32_t>>& __x, const std::vector<uint32_t, std::allocator<uint32_t>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfU32>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__206(
            self as *const crate::VectorOfU32,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfI64>> for crate::VectorOfI64 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<int64_t, std::allocator<int64_t>>& __x, const std::vector<int64_t, std::allocator<int64_t>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfI64>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__207(
            self as *const crate::VectorOfI64,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfU64>> for crate::VectorOfU64 {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<uint64_t, std::allocator<uint64_t>>& __x, const std::vector<uint64_t, std::allocator<uint64_t>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfU64>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__208(
            self as *const crate::VectorOfU64,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfUsize>> for crate::VectorOfUsize {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<size_t, std::allocator<size_t>>& __x, const std::vector<size_t, std::allocator<size_t>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfUsize>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__209(
            self as *const crate::VectorOfUsize,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::VectorOfVoid>> for crate::VectorOfVoid {
    /// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const std::vector<void*, std::allocator<void*>>& __x, const std::vector<void*, std::allocator<void*>>& __y)```</span>.
    unsafe fn ge(&self, y: &::cpp_core::Ref<crate::VectorOfVoid>) -> bool {
        crate::__ffi::ctr_cpp_std_ffi_std_operator__210(
            self as *const crate::VectorOfVoid,
            y.as_raw_ptr(),
        )
    }
}

impl ::cpp_core::CppDeletable for crate::IteratorOfOutputIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::iterator<std::output_iterator_tag, void, void, void, void>::~iterator()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_iterator_std_output_iterator_tag_void_void_void_void_diterator(self as *mut crate::IteratorOfOutputIteratorTag)
    }
}

impl ::cpp_core::CppDeletable for crate::CharTraitsOfChar {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::char_traits<char>::~char_traits()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_char_traits_char_dchar_traits(
            self as *mut crate::CharTraitsOfChar,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::CharTraitsOfWcharT {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::char_traits<wchar_t>::~char_traits()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_char_traits_wchar_t_dchar_traits(
            self as *mut crate::CharTraitsOfWcharT,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::CharTraitsOfChar16T {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::char_traits<char16_t>::~char_traits()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_char_traits_char16_t_dchar_traits(
            self as *mut crate::CharTraitsOfChar16T,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::CharTraitsOfChar32T {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void std::char_traits<char32_t>::~char_traits()```</span>.
    unsafe fn delete(&mut self) {
        crate::__ffi::ctr_cpp_std_ffi_std_char_traits_char32_t_dchar_traits(
            self as *mut crate::CharTraitsOfChar32T,
        )
    }
}

impl ::cpp_core::StaticDowncast<crate::ForwardIteratorTag> for crate::InputIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::forward_iterator_tag* static_cast<std::forward_iterator_tag*>(std::input_iterator_tag* ptr)```</span>.
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<crate::InputIteratorTag>,
    ) -> ::cpp_core::Ptr<crate::ForwardIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_static_cast_std_forward_iterator_tag_ptr(
            ptr.as_raw_ptr() as *mut crate::InputIteratorTag,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```std::forward_iterator_tag* static_cast<std::forward_iterator_tag*>(std::input_iterator_tag* ptr)```</span>.
    unsafe fn static_downcast_mut(
        ptr: ::cpp_core::MutPtr<crate::InputIteratorTag>,
    ) -> ::cpp_core::MutPtr<crate::ForwardIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_static_cast_std_forward_iterator_tag_ptr(
            ptr.as_mut_raw_ptr(),
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<crate::InputIteratorTag> for crate::ForwardIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::input_iterator_tag* static_cast<std::input_iterator_tag*>(std::forward_iterator_tag* ptr)```</span>.
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::ForwardIteratorTag>,
    ) -> ::cpp_core::Ptr<crate::InputIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_static_cast_std_input_iterator_tag_ptr(
            ptr.as_raw_ptr() as *mut crate::ForwardIteratorTag,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```std::input_iterator_tag* static_cast<std::input_iterator_tag*>(std::forward_iterator_tag* ptr)```</span>.
    unsafe fn static_upcast_mut(
        ptr: ::cpp_core::MutPtr<crate::ForwardIteratorTag>,
    ) -> ::cpp_core::MutPtr<crate::InputIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_static_cast_std_input_iterator_tag_ptr(
            ptr.as_mut_raw_ptr(),
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::ForwardIteratorTag {
    type Target = crate::InputIteratorTag;
    /// Calls C++ function: <span style='color: green;'>```std::input_iterator_tag* static_cast<std::input_iterator_tag*>(std::forward_iterator_tag* ptr)```</span>.
    fn deref(&self) -> &crate::InputIteratorTag {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_input_iterator_tag_ptr(
                self as *const crate::ForwardIteratorTag as *mut crate::ForwardIteratorTag,
            )
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::std::ops::DerefMut for crate::ForwardIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::input_iterator_tag* static_cast<std::input_iterator_tag*>(std::forward_iterator_tag* ptr)```</span>.
    fn deref_mut(&mut self) -> &mut crate::InputIteratorTag {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_input_iterator_tag_ptr(
                self as *mut crate::ForwardIteratorTag,
            )
        };
        unsafe { ffi_result.as_mut() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::StaticDowncast<crate::BidirectionalIteratorTag> for crate::ForwardIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::bidirectional_iterator_tag* static_cast<std::bidirectional_iterator_tag*>(std::forward_iterator_tag* ptr)```</span>.
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<crate::ForwardIteratorTag>,
    ) -> ::cpp_core::Ptr<crate::BidirectionalIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_bidirectional_iterator_tag_ptr(
                ptr.as_raw_ptr() as *mut crate::ForwardIteratorTag,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```std::bidirectional_iterator_tag* static_cast<std::bidirectional_iterator_tag*>(std::forward_iterator_tag* ptr)```</span>.
    unsafe fn static_downcast_mut(
        ptr: ::cpp_core::MutPtr<crate::ForwardIteratorTag>,
    ) -> ::cpp_core::MutPtr<crate::BidirectionalIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_bidirectional_iterator_tag_ptr(
                ptr.as_mut_raw_ptr(),
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<crate::ForwardIteratorTag> for crate::BidirectionalIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::forward_iterator_tag* static_cast<std::forward_iterator_tag*>(std::bidirectional_iterator_tag* ptr)```</span>.
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::BidirectionalIteratorTag>,
    ) -> ::cpp_core::Ptr<crate::ForwardIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_static_cast_std_forward_iterator_tag_ptr1(
            ptr.as_raw_ptr() as *mut crate::BidirectionalIteratorTag,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```std::forward_iterator_tag* static_cast<std::forward_iterator_tag*>(std::bidirectional_iterator_tag* ptr)```</span>.
    unsafe fn static_upcast_mut(
        ptr: ::cpp_core::MutPtr<crate::BidirectionalIteratorTag>,
    ) -> ::cpp_core::MutPtr<crate::ForwardIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_static_cast_std_forward_iterator_tag_ptr1(
            ptr.as_mut_raw_ptr(),
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::BidirectionalIteratorTag {
    type Target = crate::ForwardIteratorTag;
    /// Calls C++ function: <span style='color: green;'>```std::forward_iterator_tag* static_cast<std::forward_iterator_tag*>(std::bidirectional_iterator_tag* ptr)```</span>.
    fn deref(&self) -> &crate::ForwardIteratorTag {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_forward_iterator_tag_ptr1(
                self as *const crate::BidirectionalIteratorTag
                    as *mut crate::BidirectionalIteratorTag,
            )
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::std::ops::DerefMut for crate::BidirectionalIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::forward_iterator_tag* static_cast<std::forward_iterator_tag*>(std::bidirectional_iterator_tag* ptr)```</span>.
    fn deref_mut(&mut self) -> &mut crate::ForwardIteratorTag {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_forward_iterator_tag_ptr1(
                self as *mut crate::BidirectionalIteratorTag,
            )
        };
        unsafe { ffi_result.as_mut() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::StaticDowncast<crate::BidirectionalIteratorTag> for crate::InputIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::bidirectional_iterator_tag* static_cast<std::bidirectional_iterator_tag*>(std::input_iterator_tag* ptr)```</span>.
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<crate::InputIteratorTag>,
    ) -> ::cpp_core::Ptr<crate::BidirectionalIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_bidirectional_iterator_tag_ptr1(
                ptr.as_raw_ptr() as *mut crate::InputIteratorTag,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```std::bidirectional_iterator_tag* static_cast<std::bidirectional_iterator_tag*>(std::input_iterator_tag* ptr)```</span>.
    unsafe fn static_downcast_mut(
        ptr: ::cpp_core::MutPtr<crate::InputIteratorTag>,
    ) -> ::cpp_core::MutPtr<crate::BidirectionalIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_bidirectional_iterator_tag_ptr1(
                ptr.as_mut_raw_ptr(),
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<crate::InputIteratorTag> for crate::BidirectionalIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::input_iterator_tag* static_cast<std::input_iterator_tag*>(std::bidirectional_iterator_tag* ptr)```</span>.
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::BidirectionalIteratorTag>,
    ) -> ::cpp_core::Ptr<crate::InputIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_static_cast_std_input_iterator_tag_ptr1(
            ptr.as_raw_ptr() as *mut crate::BidirectionalIteratorTag,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```std::input_iterator_tag* static_cast<std::input_iterator_tag*>(std::bidirectional_iterator_tag* ptr)```</span>.
    unsafe fn static_upcast_mut(
        ptr: ::cpp_core::MutPtr<crate::BidirectionalIteratorTag>,
    ) -> ::cpp_core::MutPtr<crate::InputIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_static_cast_std_input_iterator_tag_ptr1(
            ptr.as_mut_raw_ptr(),
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::RandomAccessIteratorTag>
    for crate::BidirectionalIteratorTag
{
    /// Calls C++ function: <span style='color: green;'>```std::random_access_iterator_tag* static_cast<std::random_access_iterator_tag*>(std::bidirectional_iterator_tag* ptr)```</span>.
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<crate::BidirectionalIteratorTag>,
    ) -> ::cpp_core::Ptr<crate::RandomAccessIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_random_access_iterator_tag_ptr(
                ptr.as_raw_ptr() as *mut crate::BidirectionalIteratorTag,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```std::random_access_iterator_tag* static_cast<std::random_access_iterator_tag*>(std::bidirectional_iterator_tag* ptr)```</span>.
    unsafe fn static_downcast_mut(
        ptr: ::cpp_core::MutPtr<crate::BidirectionalIteratorTag>,
    ) -> ::cpp_core::MutPtr<crate::RandomAccessIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_random_access_iterator_tag_ptr(
                ptr.as_mut_raw_ptr(),
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<crate::BidirectionalIteratorTag> for crate::RandomAccessIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::bidirectional_iterator_tag* static_cast<std::bidirectional_iterator_tag*>(std::random_access_iterator_tag* ptr)```</span>.
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::RandomAccessIteratorTag>,
    ) -> ::cpp_core::Ptr<crate::BidirectionalIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_bidirectional_iterator_tag_ptr2(
                ptr.as_raw_ptr() as *mut crate::RandomAccessIteratorTag,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```std::bidirectional_iterator_tag* static_cast<std::bidirectional_iterator_tag*>(std::random_access_iterator_tag* ptr)```</span>.
    unsafe fn static_upcast_mut(
        ptr: ::cpp_core::MutPtr<crate::RandomAccessIteratorTag>,
    ) -> ::cpp_core::MutPtr<crate::BidirectionalIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_bidirectional_iterator_tag_ptr2(
                ptr.as_mut_raw_ptr(),
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::RandomAccessIteratorTag {
    type Target = crate::BidirectionalIteratorTag;
    /// Calls C++ function: <span style='color: green;'>```std::bidirectional_iterator_tag* static_cast<std::bidirectional_iterator_tag*>(std::random_access_iterator_tag* ptr)```</span>.
    fn deref(&self) -> &crate::BidirectionalIteratorTag {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_bidirectional_iterator_tag_ptr2(
                self as *const crate::RandomAccessIteratorTag
                    as *mut crate::RandomAccessIteratorTag,
            )
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::std::ops::DerefMut for crate::RandomAccessIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::bidirectional_iterator_tag* static_cast<std::bidirectional_iterator_tag*>(std::random_access_iterator_tag* ptr)```</span>.
    fn deref_mut(&mut self) -> &mut crate::BidirectionalIteratorTag {
        let ffi_result = unsafe {
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_bidirectional_iterator_tag_ptr2(
                self as *mut crate::RandomAccessIteratorTag,
            )
        };
        unsafe { ffi_result.as_mut() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::StaticDowncast<crate::RandomAccessIteratorTag> for crate::ForwardIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::random_access_iterator_tag* static_cast<std::random_access_iterator_tag*>(std::forward_iterator_tag* ptr)```</span>.
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<crate::ForwardIteratorTag>,
    ) -> ::cpp_core::Ptr<crate::RandomAccessIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_random_access_iterator_tag_ptr1(
                ptr.as_raw_ptr() as *mut crate::ForwardIteratorTag,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```std::random_access_iterator_tag* static_cast<std::random_access_iterator_tag*>(std::forward_iterator_tag* ptr)```</span>.
    unsafe fn static_downcast_mut(
        ptr: ::cpp_core::MutPtr<crate::ForwardIteratorTag>,
    ) -> ::cpp_core::MutPtr<crate::RandomAccessIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_random_access_iterator_tag_ptr1(
                ptr.as_mut_raw_ptr(),
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<crate::ForwardIteratorTag> for crate::RandomAccessIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::forward_iterator_tag* static_cast<std::forward_iterator_tag*>(std::random_access_iterator_tag* ptr)```</span>.
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::RandomAccessIteratorTag>,
    ) -> ::cpp_core::Ptr<crate::ForwardIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_static_cast_std_forward_iterator_tag_ptr2(
            ptr.as_raw_ptr() as *mut crate::RandomAccessIteratorTag,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```std::forward_iterator_tag* static_cast<std::forward_iterator_tag*>(std::random_access_iterator_tag* ptr)```</span>.
    unsafe fn static_upcast_mut(
        ptr: ::cpp_core::MutPtr<crate::RandomAccessIteratorTag>,
    ) -> ::cpp_core::MutPtr<crate::ForwardIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_static_cast_std_forward_iterator_tag_ptr2(
            ptr.as_mut_raw_ptr(),
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::RandomAccessIteratorTag> for crate::InputIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::random_access_iterator_tag* static_cast<std::random_access_iterator_tag*>(std::input_iterator_tag* ptr)```</span>.
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<crate::InputIteratorTag>,
    ) -> ::cpp_core::Ptr<crate::RandomAccessIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_random_access_iterator_tag_ptr2(
                ptr.as_raw_ptr() as *mut crate::InputIteratorTag,
            );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```std::random_access_iterator_tag* static_cast<std::random_access_iterator_tag*>(std::input_iterator_tag* ptr)```</span>.
    unsafe fn static_downcast_mut(
        ptr: ::cpp_core::MutPtr<crate::InputIteratorTag>,
    ) -> ::cpp_core::MutPtr<crate::RandomAccessIteratorTag> {
        let ffi_result =
            crate::__ffi::ctr_cpp_std_ffi_static_cast_std_random_access_iterator_tag_ptr2(
                ptr.as_mut_raw_ptr(),
            );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<crate::InputIteratorTag> for crate::RandomAccessIteratorTag {
    /// Calls C++ function: <span style='color: green;'>```std::input_iterator_tag* static_cast<std::input_iterator_tag*>(std::random_access_iterator_tag* ptr)```</span>.
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::RandomAccessIteratorTag>,
    ) -> ::cpp_core::Ptr<crate::InputIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_static_cast_std_input_iterator_tag_ptr2(
            ptr.as_raw_ptr() as *mut crate::RandomAccessIteratorTag,
        );
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```std::input_iterator_tag* static_cast<std::input_iterator_tag*>(std::random_access_iterator_tag* ptr)```</span>.
    unsafe fn static_upcast_mut(
        ptr: ::cpp_core::MutPtr<crate::RandomAccessIteratorTag>,
    ) -> ::cpp_core::MutPtr<crate::InputIteratorTag> {
        let ffi_result = crate::__ffi::ctr_cpp_std_ffi_static_cast_std_input_iterator_tag_ptr2(
            ptr.as_mut_raw_ptr(),
        );
        ::cpp_core::MutPtr::from_raw(ffi_result)
    }
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::operator+(const char* __lhs, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __rhs)```</span>.
pub unsafe fn add_char_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
) -> ::cpp_core::CppBox<crate::String> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_operator_4(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(lhs)
            .as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(rhs).as_raw_ptr(),
    );
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::operator+(const wchar_t* __lhs, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __rhs)```</span>.
pub unsafe fn add_wchar_t_w_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
) -> ::cpp_core::CppBox<crate::WString> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_operator_5(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(rhs).as_raw_ptr(),
    );
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>> std::operator+(const char16_t* __lhs, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __rhs)```</span>.
pub unsafe fn add_char16_t_u16_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
) -> ::cpp_core::CppBox<crate::U16String> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_operator_6(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(rhs).as_raw_ptr(),
    );
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>> std::operator+(const char32_t* __lhs, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __rhs)```</span>.
pub unsafe fn add_char32_t_u32_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
) -> ::cpp_core::CppBox<crate::U32String> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_operator_7(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(rhs).as_raw_ptr(),
    );
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::operator+(char __lhs, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __rhs)```</span>.
pub unsafe fn add_char_string2(
    lhs: ::std::os::raw::c_char,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
) -> ::cpp_core::CppBox<crate::String> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_operator_8(
        lhs,
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(rhs).as_raw_ptr(),
    );
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::operator+(wchar_t __lhs, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __rhs)```</span>.
pub unsafe fn add_wchar_t_w_string2(
    lhs: ::cpp_core::wchar_t,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
) -> ::cpp_core::CppBox<crate::WString> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_operator_9(
        lhs,
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(rhs).as_raw_ptr(),
    );
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>> std::operator+(char16_t __lhs, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __rhs)```</span>.
pub unsafe fn add_char16_t_u16_string2(
    lhs: ::cpp_core::char16_t,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
) -> ::cpp_core::CppBox<crate::U16String> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_operator_10(
        lhs,
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(rhs).as_raw_ptr(),
    );
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>> std::operator+(char32_t __lhs, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __rhs)```</span>.
pub unsafe fn add_char32_t_u32_string2(
    lhs: ::cpp_core::char32_t,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
) -> ::cpp_core::CppBox<crate::U32String> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_operator_11(
        lhs,
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(rhs).as_raw_ptr(),
    );
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator==(const char* __lhs, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __rhs)```</span>.
pub unsafe fn eq_char_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator__59(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(lhs)
            .as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator==(const wchar_t* __lhs, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __rhs)```</span>.
pub unsafe fn eq_wchar_t_w_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator__60(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator==(const char16_t* __lhs, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __rhs)```</span>.
pub unsafe fn eq_char16_t_u16_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator__61(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator==(const char32_t* __lhs, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __rhs)```</span>.
pub unsafe fn eq_char32_t_u32_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator__62(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const char* __lhs, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __rhs)```</span>.
pub unsafe fn ge_char_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator__99(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(lhs)
            .as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const wchar_t* __lhs, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __rhs)```</span>.
pub unsafe fn ge_wchar_t_w_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator__100(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const char16_t* __lhs, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __rhs)```</span>.
pub unsafe fn ge_char16_t_u16_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator__101(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator>=(const char32_t* __lhs, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __rhs)```</span>.
pub unsafe fn ge_char32_t_u32_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator__102(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator>(const char* __lhs, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __rhs)```</span>.
pub unsafe fn gt_char_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator_68(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(lhs)
            .as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator>(const wchar_t* __lhs, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __rhs)```</span>.
pub unsafe fn gt_wchar_t_w_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator_69(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator>(const char16_t* __lhs, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __rhs)```</span>.
pub unsafe fn gt_char16_t_u16_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator_70(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator>(const char32_t* __lhs, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __rhs)```</span>.
pub unsafe fn gt_char32_t_u32_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator_71(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const char* __lhs, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __rhs)```</span>.
pub unsafe fn le_char_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator__87(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(lhs)
            .as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const wchar_t* __lhs, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __rhs)```</span>.
pub unsafe fn le_wchar_t_w_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator__88(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const char16_t* __lhs, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __rhs)```</span>.
pub unsafe fn le_char16_t_u16_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator__89(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator<=(const char32_t* __lhs, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __rhs)```</span>.
pub unsafe fn le_char32_t_u32_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator__90(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator<(const char* __lhs, const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __rhs)```</span>.
pub unsafe fn lt_char_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::std::os::raw::c_char>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator_56(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::std::os::raw::c_char>>::cast_into(lhs)
            .as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator<(const wchar_t* __lhs, const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __rhs)```</span>.
pub unsafe fn lt_wchar_t_w_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator_57(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator<(const char16_t* __lhs, const std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __rhs)```</span>.
pub unsafe fn lt_char16_t_u16_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char16_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U16String>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator_58(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char16_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::U16String>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```bool std::operator<(const char32_t* __lhs, const std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __rhs)```</span>.
pub unsafe fn lt_char32_t_u32_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::char32_t>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::U32String>>,
) -> bool {
    crate::__ffi::ctr_cpp_std_ffi_std_operator_59(
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::char32_t>>::cast_into(lhs).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::U32String>>::cast_into(rhs).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```double std::stod(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, std::size_t* __idx = …)```</span>.
pub unsafe fn stod_string_usize(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
) -> ::std::os::raw::c_double {
    crate::__ffi::ctr_cpp_std_ffi_std_stod(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```double std::stod(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, std::size_t* __idx = …)```</span>.
pub unsafe fn stod_w_string_usize(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
) -> ::std::os::raw::c_double {
    crate::__ffi::ctr_cpp_std_ffi_std_stod1(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```double std::stod(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str)```</span>.
pub unsafe fn stod_string(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
) -> ::std::os::raw::c_double {
    crate::__ffi::ctr_cpp_std_ffi_std_stod2(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```double std::stod(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str)```</span>.
pub unsafe fn stod_w_string(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
) -> ::std::os::raw::c_double {
    crate::__ffi::ctr_cpp_std_ffi_std_stod3(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```float std::stof(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, std::size_t* __idx = …)```</span>.
pub unsafe fn stof_string_usize(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
) -> ::std::os::raw::c_float {
    crate::__ffi::ctr_cpp_std_ffi_std_stof(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```float std::stof(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, std::size_t* __idx = …)```</span>.
pub unsafe fn stof_w_string_usize(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
) -> ::std::os::raw::c_float {
    crate::__ffi::ctr_cpp_std_ffi_std_stof1(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```float std::stof(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str)```</span>.
pub unsafe fn stof_string(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
) -> ::std::os::raw::c_float {
    crate::__ffi::ctr_cpp_std_ffi_std_stof2(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```float std::stof(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str)```</span>.
pub unsafe fn stof_w_string(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
) -> ::std::os::raw::c_float {
    crate::__ffi::ctr_cpp_std_ffi_std_stof3(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```int std::stoi(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, std::size_t* __idx = …, int __base = …)```</span>.
pub unsafe fn stoi_string_usize_int(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
    base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    crate::__ffi::ctr_cpp_std_ffi_std_stoi(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
        base,
    )
}

/// Calls C++ function: <span style='color: green;'>```int std::stoi(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, std::size_t* __idx = …, int __base = …)```</span>.
pub unsafe fn stoi_w_string_usize_int(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
    base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    crate::__ffi::ctr_cpp_std_ffi_std_stoi1(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
        base,
    )
}

/// Calls C++ function: <span style='color: green;'>```int std::stoi(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, std::size_t* __idx = …)```</span>.
pub unsafe fn stoi_string_usize(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
) -> ::std::os::raw::c_int {
    crate::__ffi::ctr_cpp_std_ffi_std_stoi2(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```int std::stoi(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str)```</span>.
pub unsafe fn stoi_string(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
) -> ::std::os::raw::c_int {
    crate::__ffi::ctr_cpp_std_ffi_std_stoi3(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```int std::stoi(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, std::size_t* __idx = …)```</span>.
pub unsafe fn stoi_w_string_usize(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
) -> ::std::os::raw::c_int {
    crate::__ffi::ctr_cpp_std_ffi_std_stoi4(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```int std::stoi(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str)```</span>.
pub unsafe fn stoi_w_string(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
) -> ::std::os::raw::c_int {
    crate::__ffi::ctr_cpp_std_ffi_std_stoi5(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```long std::stol(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, std::size_t* __idx = …, int __base = …)```</span>.
pub unsafe fn stol_string_usize_int(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
    base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_long {
    crate::__ffi::ctr_cpp_std_ffi_std_stol(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
        base,
    )
}

/// Calls C++ function: <span style='color: green;'>```long std::stol(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, std::size_t* __idx = …, int __base = …)```</span>.
pub unsafe fn stol_w_string_usize_int(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
    base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_long {
    crate::__ffi::ctr_cpp_std_ffi_std_stol1(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
        base,
    )
}

/// Calls C++ function: <span style='color: green;'>```long std::stol(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, std::size_t* __idx = …)```</span>.
pub unsafe fn stol_string_usize(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
) -> ::std::os::raw::c_long {
    crate::__ffi::ctr_cpp_std_ffi_std_stol2(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```long std::stol(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str)```</span>.
pub unsafe fn stol_string(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
) -> ::std::os::raw::c_long {
    crate::__ffi::ctr_cpp_std_ffi_std_stol3(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```long std::stol(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, std::size_t* __idx = …)```</span>.
pub unsafe fn stol_w_string_usize(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
) -> ::std::os::raw::c_long {
    crate::__ffi::ctr_cpp_std_ffi_std_stol4(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```long std::stol(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str)```</span>.
pub unsafe fn stol_w_string(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
) -> ::std::os::raw::c_long {
    crate::__ffi::ctr_cpp_std_ffi_std_stol5(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```long long std::stoll(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, std::size_t* __idx = …, int __base = …)```</span>.
pub unsafe fn stoll_string_usize_int(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
    base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_longlong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoll(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
        base,
    )
}

/// Calls C++ function: <span style='color: green;'>```long long std::stoll(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, std::size_t* __idx = …, int __base = …)```</span>.
pub unsafe fn stoll_w_string_usize_int(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
    base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_longlong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoll1(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
        base,
    )
}

/// Calls C++ function: <span style='color: green;'>```long long std::stoll(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, std::size_t* __idx = …)```</span>.
pub unsafe fn stoll_string_usize(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
) -> ::std::os::raw::c_longlong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoll2(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```long long std::stoll(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str)```</span>.
pub unsafe fn stoll_string(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
) -> ::std::os::raw::c_longlong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoll3(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```long long std::stoll(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, std::size_t* __idx = …)```</span>.
pub unsafe fn stoll_w_string_usize(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
) -> ::std::os::raw::c_longlong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoll4(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```long long std::stoll(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str)```</span>.
pub unsafe fn stoll_w_string(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
) -> ::std::os::raw::c_longlong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoll5(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```unsigned long std::stoul(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, std::size_t* __idx = …, int __base = …)```</span>.
pub unsafe fn stoul_string_usize_int(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
    base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoul(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
        base,
    )
}

/// Calls C++ function: <span style='color: green;'>```unsigned long std::stoul(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, std::size_t* __idx = …, int __base = …)```</span>.
pub unsafe fn stoul_w_string_usize_int(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
    base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoul1(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
        base,
    )
}

/// Calls C++ function: <span style='color: green;'>```unsigned long std::stoul(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, std::size_t* __idx = …)```</span>.
pub unsafe fn stoul_string_usize(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
) -> ::std::os::raw::c_ulong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoul2(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```unsigned long std::stoul(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str)```</span>.
pub unsafe fn stoul_string(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
) -> ::std::os::raw::c_ulong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoul3(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```unsigned long std::stoul(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, std::size_t* __idx = …)```</span>.
pub unsafe fn stoul_w_string_usize(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
) -> ::std::os::raw::c_ulong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoul4(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```unsigned long std::stoul(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str)```</span>.
pub unsafe fn stoul_w_string(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
) -> ::std::os::raw::c_ulong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoul5(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```unsigned long long std::stoull(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, std::size_t* __idx = …, int __base = …)```</span>.
pub unsafe fn stoull_string_usize_int(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
    base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulonglong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoull(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
        base,
    )
}

/// Calls C++ function: <span style='color: green;'>```unsigned long long std::stoull(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, std::size_t* __idx = …, int __base = …)```</span>.
pub unsafe fn stoull_w_string_usize_int(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
    base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulonglong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoull1(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
        base,
    )
}

/// Calls C++ function: <span style='color: green;'>```unsigned long long std::stoull(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str, std::size_t* __idx = …)```</span>.
pub unsafe fn stoull_string_usize(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
) -> ::std::os::raw::c_ulonglong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoull2(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```unsigned long long std::stoull(const std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __str)```</span>.
pub unsafe fn stoull_string(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::String>>,
) -> ::std::os::raw::c_ulonglong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoull3(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::String>>::cast_into(str).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```unsigned long long std::stoull(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str, std::size_t* __idx = …)```</span>.
pub unsafe fn stoull_w_string_usize(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
    idx: impl ::cpp_core::CastInto<::cpp_core::MutPtr<usize>>,
) -> ::std::os::raw::c_ulonglong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoull4(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutPtr<usize>>::cast_into(idx).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```unsigned long long std::stoull(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __str)```</span>.
pub unsafe fn stoull_w_string(
    str: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::WString>>,
) -> ::std::os::raw::c_ulonglong {
    crate::__ffi::ctr_cpp_std_ffi_std_stoull5(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::WString>>::cast_into(str).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __lhs, std::basic_string<char, std::char_traits<char>, std::allocator<char>>& __rhs)```</span>.
pub unsafe fn swap_2_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::String>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::String>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::String>>::cast_into(lhs).as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::String>>::cast_into(rhs).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __lhs, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>& __rhs)```</span>.
pub unsafe fn swap_2_w_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::WString>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::WString>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap1(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::WString>>::cast_into(lhs).as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::WString>>::cast_into(rhs).as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __lhs, std::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>& __rhs)```</span>.
pub unsafe fn swap_2_u16_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::U16String>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::U16String>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap2(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::U16String>>::cast_into(lhs)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::U16String>>::cast_into(rhs)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __lhs, std::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>& __rhs)```</span>.
pub unsafe fn swap_2_u32_string(
    lhs: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::U32String>>,
    rhs: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::U32String>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap3(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::U32String>>::cast_into(lhs)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::U32String>>::cast_into(rhs)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<bool, std::allocator<bool>>& __x, std::vector<bool, std::allocator<bool>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_bool(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfBool>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfBool>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap4(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfBool>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfBool>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<char, std::allocator<char>>& __x, std::vector<char, std::allocator<char>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_char(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfChar>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfChar>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap5(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfChar>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfChar>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<signed char, std::allocator<signed char>>& __x, std::vector<signed char, std::allocator<signed char>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_schar(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfSchar>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfSchar>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap6(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfSchar>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfSchar>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<unsigned char, std::allocator<unsigned char>>& __x, std::vector<unsigned char, std::allocator<unsigned char>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_uchar(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUchar>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUchar>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap7(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUchar>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUchar>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<wchar_t, std::allocator<wchar_t>>& __x, std::vector<wchar_t, std::allocator<wchar_t>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_wchar_t(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfWcharT>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfWcharT>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap8(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfWcharT>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfWcharT>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<char16_t, std::allocator<char16_t>>& __x, std::vector<char16_t, std::allocator<char16_t>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_char16_t(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfChar16T>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfChar16T>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap9(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfChar16T>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfChar16T>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<char32_t, std::allocator<char32_t>>& __x, std::vector<char32_t, std::allocator<char32_t>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_char32_t(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfChar32T>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfChar32T>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap10(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfChar32T>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfChar32T>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<short, std::allocator<short>>& __x, std::vector<short, std::allocator<short>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_short(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfShort>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfShort>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap11(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfShort>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfShort>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<unsigned short, std::allocator<unsigned short>>& __x, std::vector<unsigned short, std::allocator<unsigned short>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_ushort(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUshort>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUshort>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap12(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUshort>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUshort>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<int, std::allocator<int>>& __x, std::vector<int, std::allocator<int>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_int(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfInt>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfInt>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap13(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfInt>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfInt>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<unsigned int, std::allocator<unsigned int>>& __x, std::vector<unsigned int, std::allocator<unsigned int>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_uint(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUint>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUint>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap14(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUint>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUint>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<long, std::allocator<long>>& __x, std::vector<long, std::allocator<long>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_long(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfLong>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfLong>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap15(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfLong>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfLong>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<unsigned long, std::allocator<unsigned long>>& __x, std::vector<unsigned long, std::allocator<unsigned long>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_ulong(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUlong>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUlong>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap16(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUlong>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUlong>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<long long, std::allocator<long long>>& __x, std::vector<long long, std::allocator<long long>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_longlong(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfLonglong>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfLonglong>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap17(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfLonglong>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfLonglong>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<unsigned long long, std::allocator<unsigned long long>>& __x, std::vector<unsigned long long, std::allocator<unsigned long long>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_ulonglong(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUlonglong>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUlonglong>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap18(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUlonglong>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUlonglong>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<float, std::allocator<float>>& __x, std::vector<float, std::allocator<float>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_float(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfFloat>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfFloat>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap19(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfFloat>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfFloat>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<double, std::allocator<double>>& __x, std::vector<double, std::allocator<double>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_double(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfDouble>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfDouble>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap20(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfDouble>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfDouble>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<int8_t, std::allocator<int8_t>>& __x, std::vector<int8_t, std::allocator<int8_t>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_i8(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfI8>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfI8>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap21(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfI8>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfI8>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<uint8_t, std::allocator<uint8_t>>& __x, std::vector<uint8_t, std::allocator<uint8_t>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_u8(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfU8>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfU8>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap22(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfU8>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfU8>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<int16_t, std::allocator<int16_t>>& __x, std::vector<int16_t, std::allocator<int16_t>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_i16(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfI16>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfI16>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap23(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfI16>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfI16>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<uint16_t, std::allocator<uint16_t>>& __x, std::vector<uint16_t, std::allocator<uint16_t>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_u16(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfU16>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfU16>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap24(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfU16>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfU16>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<int32_t, std::allocator<int32_t>>& __x, std::vector<int32_t, std::allocator<int32_t>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_i32(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfI32>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfI32>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap25(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfI32>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfI32>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<uint32_t, std::allocator<uint32_t>>& __x, std::vector<uint32_t, std::allocator<uint32_t>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_u32(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfU32>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfU32>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap26(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfU32>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfU32>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<int64_t, std::allocator<int64_t>>& __x, std::vector<int64_t, std::allocator<int64_t>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_i64(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfI64>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfI64>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap27(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfI64>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfI64>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<uint64_t, std::allocator<uint64_t>>& __x, std::vector<uint64_t, std::allocator<uint64_t>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_u64(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfU64>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfU64>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap28(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfU64>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfU64>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<size_t, std::allocator<size_t>>& __x, std::vector<size_t, std::allocator<size_t>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_usize(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUsize>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfUsize>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap29(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUsize>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfUsize>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```void std::swap(std::vector<void*, std::allocator<void*>>& __x, std::vector<void*, std::allocator<void*>>& __y)```</span>.
pub unsafe fn swap_2_vector_of_void(
    x: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfVoid>>,
    y: impl ::cpp_core::CastInto<::cpp_core::MutRef<crate::VectorOfVoid>>,
) {
    crate::__ffi::ctr_cpp_std_ffi_std_swap30(
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfVoid>>::cast_into(x)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::MutRef<crate::VectorOfVoid>>::cast_into(y)
            .as_mut_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::to_string(int __val)```</span>.
pub unsafe fn to_string_int(val: ::std::os::raw::c_int) -> ::cpp_core::CppBox<crate::String> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_string(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::to_string(unsigned int __val)```</span>.
pub unsafe fn to_string_uint(val: ::std::os::raw::c_uint) -> ::cpp_core::CppBox<crate::String> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_string1(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::to_string(long __val)```</span>.
pub unsafe fn to_string_long(val: ::std::os::raw::c_long) -> ::cpp_core::CppBox<crate::String> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_string2(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::to_string(unsigned long __val)```</span>.
pub unsafe fn to_string_ulong(val: ::std::os::raw::c_ulong) -> ::cpp_core::CppBox<crate::String> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_string3(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::to_string(long long __val)```</span>.
pub unsafe fn to_string_longlong(
    val: ::std::os::raw::c_longlong,
) -> ::cpp_core::CppBox<crate::String> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_string4(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::to_string(unsigned long long __val)```</span>.
pub unsafe fn to_string_ulonglong(
    val: ::std::os::raw::c_ulonglong,
) -> ::cpp_core::CppBox<crate::String> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_string5(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::to_string(float __val)```</span>.
pub unsafe fn to_string_float(val: ::std::os::raw::c_float) -> ::cpp_core::CppBox<crate::String> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_string6(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<char, std::char_traits<char>, std::allocator<char>> std::to_string(double __val)```</span>.
pub unsafe fn to_string_double(val: ::std::os::raw::c_double) -> ::cpp_core::CppBox<crate::String> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_string7(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::to_wstring(int __val)```</span>.
pub unsafe fn to_wstring_int(val: ::std::os::raw::c_int) -> ::cpp_core::CppBox<crate::WString> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_wstring(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::to_wstring(unsigned int __val)```</span>.
pub unsafe fn to_wstring_uint(val: ::std::os::raw::c_uint) -> ::cpp_core::CppBox<crate::WString> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_wstring1(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::to_wstring(long __val)```</span>.
pub unsafe fn to_wstring_long(val: ::std::os::raw::c_long) -> ::cpp_core::CppBox<crate::WString> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_wstring2(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::to_wstring(unsigned long __val)```</span>.
pub unsafe fn to_wstring_ulong(val: ::std::os::raw::c_ulong) -> ::cpp_core::CppBox<crate::WString> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_wstring3(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::to_wstring(long long __val)```</span>.
pub unsafe fn to_wstring_longlong(
    val: ::std::os::raw::c_longlong,
) -> ::cpp_core::CppBox<crate::WString> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_wstring4(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::to_wstring(unsigned long long __val)```</span>.
pub unsafe fn to_wstring_ulonglong(
    val: ::std::os::raw::c_ulonglong,
) -> ::cpp_core::CppBox<crate::WString> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_wstring5(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::to_wstring(float __val)```</span>.
pub unsafe fn to_wstring_float(val: ::std::os::raw::c_float) -> ::cpp_core::CppBox<crate::WString> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_wstring6(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> std::to_wstring(double __val)```</span>.
pub unsafe fn to_wstring_double(
    val: ::std::os::raw::c_double,
) -> ::cpp_core::CppBox<crate::WString> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_to_wstring7(val);
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```wchar_t* std::wcschr(wchar_t* __p, wchar_t __c)```</span>.
pub unsafe fn wcschr(
    p: impl ::cpp_core::CastInto<::cpp_core::MutPtr<::cpp_core::wchar_t>>,
    c: ::cpp_core::wchar_t,
) -> ::cpp_core::MutPtr<::cpp_core::wchar_t> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_wcschr(
        ::cpp_core::CastInto::<::cpp_core::MutPtr<::cpp_core::wchar_t>>::cast_into(p)
            .as_mut_raw_ptr(),
        c,
    );
    ::cpp_core::MutPtr::from_raw(ffi_result)
}

/// Calls C++ function: <span style='color: green;'>```wchar_t* std::wcspbrk(wchar_t* __s1, const wchar_t* __s2)```</span>.
pub unsafe fn wcspbrk(
    s1: impl ::cpp_core::CastInto<::cpp_core::MutPtr<::cpp_core::wchar_t>>,
    s2: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
) -> ::cpp_core::MutPtr<::cpp_core::wchar_t> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_wcspbrk(
        ::cpp_core::CastInto::<::cpp_core::MutPtr<::cpp_core::wchar_t>>::cast_into(s1)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s2).as_raw_ptr(),
    );
    ::cpp_core::MutPtr::from_raw(ffi_result)
}

/// Calls C++ function: <span style='color: green;'>```wchar_t* std::wcsrchr(wchar_t* __p, wchar_t __c)```</span>.
pub unsafe fn wcsrchr(
    p: impl ::cpp_core::CastInto<::cpp_core::MutPtr<::cpp_core::wchar_t>>,
    c: ::cpp_core::wchar_t,
) -> ::cpp_core::MutPtr<::cpp_core::wchar_t> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_wcsrchr(
        ::cpp_core::CastInto::<::cpp_core::MutPtr<::cpp_core::wchar_t>>::cast_into(p)
            .as_mut_raw_ptr(),
        c,
    );
    ::cpp_core::MutPtr::from_raw(ffi_result)
}

/// Calls C++ function: <span style='color: green;'>```wchar_t* std::wcsstr(wchar_t* __s1, const wchar_t* __s2)```</span>.
pub unsafe fn wcsstr(
    s1: impl ::cpp_core::CastInto<::cpp_core::MutPtr<::cpp_core::wchar_t>>,
    s2: impl ::cpp_core::CastInto<::cpp_core::Ptr<::cpp_core::wchar_t>>,
) -> ::cpp_core::MutPtr<::cpp_core::wchar_t> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_wcsstr(
        ::cpp_core::CastInto::<::cpp_core::MutPtr<::cpp_core::wchar_t>>::cast_into(s1)
            .as_mut_raw_ptr(),
        ::cpp_core::CastInto::<::cpp_core::Ptr<::cpp_core::wchar_t>>::cast_into(s2).as_raw_ptr(),
    );
    ::cpp_core::MutPtr::from_raw(ffi_result)
}

/// Calls C++ function: <span style='color: green;'>```wchar_t* std::wmemchr(wchar_t* __p, wchar_t __c, std::size_t __n)```</span>.
pub unsafe fn wmemchr(
    p: impl ::cpp_core::CastInto<::cpp_core::MutPtr<::cpp_core::wchar_t>>,
    c: ::cpp_core::wchar_t,
    n: usize,
) -> ::cpp_core::MutPtr<::cpp_core::wchar_t> {
    let ffi_result = crate::__ffi::ctr_cpp_std_ffi_std_wmemchr(
        ::cpp_core::CastInto::<::cpp_core::MutPtr<::cpp_core::wchar_t>>::cast_into(p)
            .as_mut_raw_ptr(),
        c,
        n,
    );
    ::cpp_core::MutPtr::from_raw(ffi_result)
}